1 //------------------------------------------------------------------------------
2 // GB_mx_string_to_BinaryOp.c: get a GraphBLAS operator from MATLAB strings
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 #include "GB_mex.h"
11
12 // opname_mx: a MATLAB string defining the operator name:
13 // 10: first, second, pair, min, max, plus, minus, rminus, times, div, rdiv
14 // 6: iseq, isne, isgt, islt, isge, isle,
15 // 6: eq, ne, gt, lt, ge, le,
16 // 3: or, and, xor
17 // ... and more
18
19 // optype_mx: a MATLAB string defining one of 11 operator types:
20 // 'logical', 'int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64',
21 // 'uint64', 'single', 'double', 'single complex', or 'double complex'
22
23 // default_optype: default operator type if optype_mx is NULL or if
24 // the type is not part of the string
25
GB_mx_string_to_BinaryOp(GrB_BinaryOp * op_handle,const GrB_Type default_optype,const mxArray * opname_mx,const mxArray * optype_mx,const bool user_complex)26 bool GB_mx_string_to_BinaryOp // true if successful, false otherwise
27 (
28 GrB_BinaryOp *op_handle, // the binary op
29 const GrB_Type default_optype, // default operator type
30 const mxArray *opname_mx, // MATLAB string with operator name
31 const mxArray *optype_mx, // MATLAB string with operator type
32 const bool user_complex // if true, use user-defined Complex op
33 )
34 {
35
36 (*op_handle) = NULL ;
37 GrB_BinaryOp op = NULL ;
38
39 //--------------------------------------------------------------------------
40 // get the string
41 //--------------------------------------------------------------------------
42
43 #define LEN 256
44 char opname [LEN+2] ;
45 int len = GB_mx_mxArray_to_string (opname, LEN, opname_mx) ;
46 if (len < 0)
47 {
48 return (false) ;
49 }
50 if (len == 0)
51 {
52 op = NULL ; // op is not present
53 return (true) ;
54 }
55
56 bool cmplx_op = MATCH (opname, "cmplx") || MATCH (opname, "complex" ) ;
57
58 // get the optype from the optype_mx string, if present
59 GrB_Type optype = GB_mx_string_to_Type (optype_mx, default_optype) ;
60 if (optype == NULL)
61 {
62 mexWarnMsgIdAndTxt ("GB:warn", "unrecognized op type") ;
63 return (false) ;
64 }
65
66 //--------------------------------------------------------------------------
67 // convert the string to a GraphBLAS binary operator, built-in or Complex
68 //--------------------------------------------------------------------------
69
70 if (user_complex && (optype == Complex || cmplx_op))
71 {
72
73 //----------------------------------------------------------------------
74 // user-defined operators for the Complex type
75 //----------------------------------------------------------------------
76
77 // 12 binary operators z=f(x,y), all x,y,z are Complex
78 if (MATCH (opname, "first" )) { op = Complex_first ; }
79 else if (MATCH (opname, "second" )) { op = Complex_second ; }
80 else if (MATCH (opname, "pair" )) { op = Complex_pair ; }
81 else if (MATCH (opname, "any" )) { op = Complex_second ; }
82 else if (MATCH (opname, "min" )) { op = Complex_min ; }
83 else if (MATCH (opname, "max" )) { op = Complex_max ; }
84 else if (MATCH (opname, "plus" )) { op = Complex_plus ; }
85 else if (MATCH (opname, "minus" )) { op = Complex_minus ; }
86 else if (MATCH (opname, "rminus" )) { op = Complex_rminus ; }
87 else if (MATCH (opname, "times" )) { op = Complex_times ; }
88 else if (MATCH (opname, "div" )) { op = Complex_div ; }
89 else if (MATCH (opname, "rdiv" )) { op = Complex_rdiv ; }
90
91 // 6 ops z=f(x,y), where x,y are Complex, z = (1,0) or (0,0)
92 else if (MATCH (opname, "iseq" )) { op = Complex_iseq ; }
93 else if (MATCH (opname, "isne" )) { op = Complex_isne ; }
94 else if (MATCH (opname, "isgt" )) { op = Complex_isgt ; }
95 else if (MATCH (opname, "islt" )) { op = Complex_islt ; }
96 else if (MATCH (opname, "isge" )) { op = Complex_isge ; }
97 else if (MATCH (opname, "isle" )) { op = Complex_isle ; }
98
99 // 3 binary operators z=f(x,y), all x,y,x the same type
100 else if (MATCH (opname, "or" )) { op = Complex_or ; }
101 else if (MATCH (opname, "and" )) { op = Complex_and ; }
102 else if (MATCH (opname, "xor" )) { op = Complex_xor ; }
103
104 // 6 ops z=f(x,y), where x,y are Complex type but z is boolean
105 else if (MATCH (opname, "eq" )) { op = Complex_eq ; }
106 else if (MATCH (opname, "ne" )) { op = Complex_ne ; }
107 else if (MATCH (opname, "gt" )) { op = Complex_gt ; }
108 else if (MATCH (opname, "lt" )) { op = Complex_lt ; }
109 else if (MATCH (opname, "ge" )) { op = Complex_ge ; }
110 else if (MATCH (opname, "le" )) { op = Complex_le ; }
111
112 // z is complex, x and y are real
113 else if (cmplx_op) { op = Complex_complex ; }
114
115 else
116 {
117 mexWarnMsgIdAndTxt ("GB:warn", "Complex op unrecognized") ;
118 }
119
120 }
121 else
122 {
123
124 //----------------------------------------------------------------------
125 // built-in binary operator
126 //----------------------------------------------------------------------
127
128 GB_Opcode opcode ;
129
130 // 12 binary operators z=f(x,y), all x,y,z of the same type
131 if (MATCH (opname, "first" )) { opcode = GB_FIRST_opcode ; }
132 else if (MATCH (opname, "second" )) { opcode = GB_SECOND_opcode ; }
133 else if (MATCH (opname, "pair" )) { opcode = GB_PAIR_opcode ; }
134 else if (MATCH (opname, "any" )) { opcode = GB_ANY_opcode ; }
135 else if (MATCH (opname, "min" )) { opcode = GB_MIN_opcode ; }
136 else if (MATCH (opname, "max" )) { opcode = GB_MAX_opcode ; }
137 else if (MATCH (opname, "plus" )) { opcode = GB_PLUS_opcode ; }
138 else if (MATCH (opname, "minus" )) { opcode = GB_MINUS_opcode ; }
139 else if (MATCH (opname, "rminus" )) { opcode = GB_RMINUS_opcode ; }
140 else if (MATCH (opname, "times" )) { opcode = GB_TIMES_opcode ; }
141 else if (MATCH (opname, "div" )) { opcode = GB_DIV_opcode ; }
142 else if (MATCH (opname, "rdiv" )) { opcode = GB_RDIV_opcode ; }
143
144 // 6 ops z=f(x,y), all x,y,z the same type
145 else if (MATCH (opname, "iseq" )) { opcode = GB_ISEQ_opcode ; }
146 else if (MATCH (opname, "isne" )) { opcode = GB_ISNE_opcode ; }
147 else if (MATCH (opname, "isgt" )) { opcode = GB_ISGT_opcode ; }
148 else if (MATCH (opname, "islt" )) { opcode = GB_ISLT_opcode ; }
149 else if (MATCH (opname, "isge" )) { opcode = GB_ISGE_opcode ; }
150 else if (MATCH (opname, "isle" )) { opcode = GB_ISLE_opcode ; }
151
152 // 3 binary operators z=f(x,y), all x,y,x the same type
153 else if (MATCH (opname, "or" ) ||
154 MATCH (opname, "lor" )) { opcode = GB_LOR_opcode ; }
155 else if (MATCH (opname, "and" ) ||
156 MATCH (opname, "land" )) { opcode = GB_LAND_opcode ; }
157 else if (MATCH (opname, "xor" ) ||
158 MATCH (opname, "lxor" )) { opcode = GB_LXOR_opcode ; }
159
160 // 6 ops z=f(x,y), where x,y are the requested type but z is boolean
161 else if (MATCH (opname, "eq" )) { opcode = GB_EQ_opcode ; }
162 else if (MATCH (opname, "ne" )) { opcode = GB_NE_opcode ; }
163 else if (MATCH (opname, "gt" )) { opcode = GB_GT_opcode ; }
164 else if (MATCH (opname, "lt" )) { opcode = GB_LT_opcode ; }
165 else if (MATCH (opname, "ge" )) { opcode = GB_GE_opcode ; }
166 else if (MATCH (opname, "le" )) { opcode = GB_LE_opcode ; }
167
168 else if (MATCH (opname, "atan2" )) { opcode = GB_ATAN2_opcode ; }
169 else if (MATCH (opname, "hypot" )) { opcode = GB_HYPOT_opcode ; }
170 else if (MATCH (opname, "fmod" )) { opcode = GB_FMOD_opcode ; }
171 else if (MATCH (opname,"remainder")) { opcode = GB_REMAINDER_opcode ; }
172 else if (MATCH (opname, "copysign")) { opcode = GB_COPYSIGN_opcode ; }
173 else if (MATCH (opname, "ldexp" )) { opcode = GB_LDEXP_opcode ; }
174 else if (MATCH (opname, "pow" )) { opcode = GB_POW_opcode ; }
175
176 // positional ops
177 else if (MATCH (opname, "firsti" ) ||
178 MATCH (opname, "1sti" )) { opcode = GB_FIRSTI_opcode ; }
179 else if (MATCH (opname, "firsti1" ) ||
180 MATCH (opname, "1sti1" )) { opcode = GB_FIRSTI1_opcode ; }
181 else if (MATCH (opname, "firstj" ) ||
182 MATCH (opname, "1stj" )) { opcode = GB_FIRSTJ_opcode ; }
183 else if (MATCH (opname, "firstj1" ) ||
184 MATCH (opname, "1stj1" )) { opcode = GB_FIRSTJ1_opcode ; }
185 else if (MATCH (opname, "secondi" ) ||
186 MATCH (opname, "2ndi" )) { opcode = GB_SECONDI_opcode ; }
187 else if (MATCH (opname, "secondi1") ||
188 MATCH (opname, "2ndi1" )) { opcode = GB_SECONDI1_opcode ; }
189 else if (MATCH (opname, "secondj" ) ||
190 MATCH (opname, "2ndj" )) { opcode = GB_SECONDJ_opcode ; }
191 else if (MATCH (opname, "secondj1") ||
192 MATCH (opname, "2ndj1" )) { opcode = GB_SECONDJ1_opcode ; }
193
194 // z is complex, x and y are real
195 else if (cmplx_op ) { opcode = GB_CMPLX_opcode ; }
196
197 // bitwise operators
198 else if (MATCH (opname, "bitor" ) ||
199 MATCH (opname, "bor" )) { opcode = GB_BOR_opcode ; }
200 else if (MATCH (opname, "bitand" ) ||
201 MATCH (opname, "band" )) { opcode = GB_BAND_opcode ; }
202 else if (MATCH (opname, "bitxor" ) ||
203 MATCH (opname, "bxor" )) { opcode = GB_BXOR_opcode ; }
204 else if (MATCH (opname, "bitxnor" ) ||
205 MATCH (opname, "bxnor" )) { opcode = GB_BXNOR_opcode ; }
206 else if (MATCH (opname, "bitget" ) ||
207 MATCH (opname, "bget" )) { opcode = GB_BGET_opcode ; }
208 else if (MATCH (opname, "bitset" ) ||
209 MATCH (opname, "bset" )) { opcode = GB_BSET_opcode ; }
210 else if (MATCH (opname, "bitclr" ) ||
211 MATCH (opname, "bclr" )) { opcode = GB_BCLR_opcode ; }
212 else if (MATCH (opname, "bitshift") ||
213 MATCH (opname, "bshift" )) { opcode = GB_BSHIFT_opcode ; }
214
215 else
216 {
217 mexWarnMsgIdAndTxt ("GB:warn", "unrecognized function name") ;
218 return (false) ;
219 }
220
221 GB_Type_code xcode = optype->code ;
222 bool is64 = (xcode == GB_INT64_code) ;
223
224 if (GB_OPCODE_IS_POSITIONAL (opcode))
225 {
226 if (! (xcode == GB_INT64_code || xcode == GB_INT32_code))
227 {
228 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
229 return (false) ;
230 }
231 }
232
233 switch (opcode)
234 {
235
236 case GB_FIRST_opcode :
237
238 switch (xcode)
239 {
240 case GB_BOOL_code : op = GrB_FIRST_BOOL ; break ;
241 case GB_INT8_code : op = GrB_FIRST_INT8 ; break ;
242 case GB_INT16_code : op = GrB_FIRST_INT16 ; break ;
243 case GB_INT32_code : op = GrB_FIRST_INT32 ; break ;
244 case GB_INT64_code : op = GrB_FIRST_INT64 ; break ;
245 case GB_UINT8_code : op = GrB_FIRST_UINT8 ; break ;
246 case GB_UINT16_code : op = GrB_FIRST_UINT16 ; break ;
247 case GB_UINT32_code : op = GrB_FIRST_UINT32 ; break ;
248 case GB_UINT64_code : op = GrB_FIRST_UINT64 ; break ;
249 case GB_FP32_code : op = GrB_FIRST_FP32 ; break ;
250 case GB_FP64_code : op = GrB_FIRST_FP64 ; break ;
251 case GB_FC32_code : op = GxB_FIRST_FC32 ; break ;
252 case GB_FC64_code : op = GxB_FIRST_FC64 ; break ;
253 default :
254 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
255 return (false) ;
256 }
257 break ;
258
259 case GB_SECOND_opcode:
260
261 switch (xcode)
262 {
263 case GB_BOOL_code : op = GrB_SECOND_BOOL ; break ;
264 case GB_INT8_code : op = GrB_SECOND_INT8 ; break ;
265 case GB_INT16_code : op = GrB_SECOND_INT16 ; break ;
266 case GB_INT32_code : op = GrB_SECOND_INT32 ; break ;
267 case GB_INT64_code : op = GrB_SECOND_INT64 ; break ;
268 case GB_UINT8_code : op = GrB_SECOND_UINT8 ; break ;
269 case GB_UINT16_code : op = GrB_SECOND_UINT16 ; break ;
270 case GB_UINT32_code : op = GrB_SECOND_UINT32 ; break ;
271 case GB_UINT64_code : op = GrB_SECOND_UINT64 ; break ;
272 case GB_FP32_code : op = GrB_SECOND_FP32 ; break ;
273 case GB_FP64_code : op = GrB_SECOND_FP64 ; break ;
274 case GB_FC32_code : op = GxB_SECOND_FC32 ; break ;
275 case GB_FC64_code : op = GxB_SECOND_FC64 ; break ;
276 default :
277 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
278 return (false) ;
279 }
280 break ;
281
282 case GB_ANY_opcode:
283
284 switch (xcode)
285 {
286 case GB_BOOL_code : op = GxB_ANY_BOOL ; break ;
287 case GB_INT8_code : op = GxB_ANY_INT8 ; break ;
288 case GB_INT16_code : op = GxB_ANY_INT16 ; break ;
289 case GB_INT32_code : op = GxB_ANY_INT32 ; break ;
290 case GB_INT64_code : op = GxB_ANY_INT64 ; break ;
291 case GB_UINT8_code : op = GxB_ANY_UINT8 ; break ;
292 case GB_UINT16_code : op = GxB_ANY_UINT16 ; break ;
293 case GB_UINT32_code : op = GxB_ANY_UINT32 ; break ;
294 case GB_UINT64_code : op = GxB_ANY_UINT64 ; break ;
295 case GB_FP32_code : op = GxB_ANY_FP32 ; break ;
296 case GB_FP64_code : op = GxB_ANY_FP64 ; break ;
297 case GB_FC32_code : op = GxB_ANY_FC32 ; break ;
298 case GB_FC64_code : op = GxB_ANY_FC64 ; break ;
299 default :
300 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
301 return (false) ;
302 }
303 break ;
304
305 case GB_PAIR_opcode:
306
307 switch (xcode)
308 {
309 case GB_BOOL_code : op = GxB_PAIR_BOOL ; break ;
310 case GB_INT8_code : op = GxB_PAIR_INT8 ; break ;
311 case GB_INT16_code : op = GxB_PAIR_INT16 ; break ;
312 case GB_INT32_code : op = GxB_PAIR_INT32 ; break ;
313 case GB_INT64_code : op = GxB_PAIR_INT64 ; break ;
314 case GB_UINT8_code : op = GxB_PAIR_UINT8 ; break ;
315 case GB_UINT16_code : op = GxB_PAIR_UINT16 ; break ;
316 case GB_UINT32_code : op = GxB_PAIR_UINT32 ; break ;
317 case GB_UINT64_code : op = GxB_PAIR_UINT64 ; break ;
318 case GB_FP32_code : op = GxB_PAIR_FP32 ; break ;
319 case GB_FP64_code : op = GxB_PAIR_FP64 ; break ;
320 case GB_FC32_code : op = GxB_PAIR_FC32 ; break ;
321 case GB_FC64_code : op = GxB_PAIR_FC64 ; break ;
322 default :
323 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
324 return (false) ;
325 }
326 break ;
327
328 case GB_MIN_opcode :
329
330 switch (xcode)
331 {
332 case GB_BOOL_code : op = GrB_MIN_BOOL ; break ;
333 case GB_INT8_code : op = GrB_MIN_INT8 ; break ;
334 case GB_INT16_code : op = GrB_MIN_INT16 ; break ;
335 case GB_INT32_code : op = GrB_MIN_INT32 ; break ;
336 case GB_INT64_code : op = GrB_MIN_INT64 ; break ;
337 case GB_UINT8_code : op = GrB_MIN_UINT8 ; break ;
338 case GB_UINT16_code : op = GrB_MIN_UINT16 ; break ;
339 case GB_UINT32_code : op = GrB_MIN_UINT32 ; break ;
340 case GB_UINT64_code : op = GrB_MIN_UINT64 ; break ;
341 case GB_FP32_code : op = GrB_MIN_FP32 ; break ;
342 case GB_FP64_code : op = GrB_MIN_FP64 ; break ;
343 default :
344 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
345 break ;
346 }
347 break ;
348
349 case GB_MAX_opcode :
350
351 switch (xcode)
352 {
353 case GB_BOOL_code : op = GrB_MAX_BOOL ; break ;
354 case GB_INT8_code : op = GrB_MAX_INT8 ; break ;
355 case GB_INT16_code : op = GrB_MAX_INT16 ; break ;
356 case GB_INT32_code : op = GrB_MAX_INT32 ; break ;
357 case GB_INT64_code : op = GrB_MAX_INT64 ; break ;
358 case GB_UINT8_code : op = GrB_MAX_UINT8 ; break ;
359 case GB_UINT16_code : op = GrB_MAX_UINT16 ; break ;
360 case GB_UINT32_code : op = GrB_MAX_UINT32 ; break ;
361 case GB_UINT64_code : op = GrB_MAX_UINT64 ; break ;
362 case GB_FP32_code : op = GrB_MAX_FP32 ; break ;
363 case GB_FP64_code : op = GrB_MAX_FP64 ; break ;
364 default :
365 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
366 return (false) ;
367 }
368 break ;
369
370 case GB_PLUS_opcode :
371
372 switch (xcode)
373 {
374 case GB_BOOL_code : op = GrB_PLUS_BOOL ; break ;
375 case GB_INT8_code : op = GrB_PLUS_INT8 ; break ;
376 case GB_INT16_code : op = GrB_PLUS_INT16 ; break ;
377 case GB_INT32_code : op = GrB_PLUS_INT32 ; break ;
378 case GB_INT64_code : op = GrB_PLUS_INT64 ; break ;
379 case GB_UINT8_code : op = GrB_PLUS_UINT8 ; break ;
380 case GB_UINT16_code : op = GrB_PLUS_UINT16 ; break ;
381 case GB_UINT32_code : op = GrB_PLUS_UINT32 ; break ;
382 case GB_UINT64_code : op = GrB_PLUS_UINT64 ; break ;
383 case GB_FP32_code : op = GrB_PLUS_FP32 ; break ;
384 case GB_FP64_code : op = GrB_PLUS_FP64 ; break ;
385 case GB_FC32_code : op = GxB_PLUS_FC32 ; break ;
386 case GB_FC64_code : op = GxB_PLUS_FC64 ; break ;
387 default :
388 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
389 return (false) ;
390 }
391 break ;
392
393 case GB_MINUS_opcode :
394
395 switch (xcode)
396 {
397 case GB_BOOL_code : op = GrB_MINUS_BOOL ; break ;
398 case GB_INT8_code : op = GrB_MINUS_INT8 ; break ;
399 case GB_INT16_code : op = GrB_MINUS_INT16 ; break ;
400 case GB_INT32_code : op = GrB_MINUS_INT32 ; break ;
401 case GB_INT64_code : op = GrB_MINUS_INT64 ; break ;
402 case GB_UINT8_code : op = GrB_MINUS_UINT8 ; break ;
403 case GB_UINT16_code : op = GrB_MINUS_UINT16 ; break ;
404 case GB_UINT32_code : op = GrB_MINUS_UINT32 ; break ;
405 case GB_UINT64_code : op = GrB_MINUS_UINT64 ; break ;
406 case GB_FP32_code : op = GrB_MINUS_FP32 ; break ;
407 case GB_FP64_code : op = GrB_MINUS_FP64 ; break ;
408 case GB_FC32_code : op = GxB_MINUS_FC32 ; break ;
409 case GB_FC64_code : op = GxB_MINUS_FC64 ; break ;
410 default :
411 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
412 return (false) ;
413 }
414 break ;
415
416 case GB_RMINUS_opcode :
417
418 switch (xcode)
419 {
420 case GB_BOOL_code : op = GxB_RMINUS_BOOL ; break ;
421 case GB_INT8_code : op = GxB_RMINUS_INT8 ; break ;
422 case GB_INT16_code : op = GxB_RMINUS_INT16 ; break ;
423 case GB_INT32_code : op = GxB_RMINUS_INT32 ; break ;
424 case GB_INT64_code : op = GxB_RMINUS_INT64 ; break ;
425 case GB_UINT8_code : op = GxB_RMINUS_UINT8 ; break ;
426 case GB_UINT16_code : op = GxB_RMINUS_UINT16 ; break ;
427 case GB_UINT32_code : op = GxB_RMINUS_UINT32 ; break ;
428 case GB_UINT64_code : op = GxB_RMINUS_UINT64 ; break ;
429 case GB_FP32_code : op = GxB_RMINUS_FP32 ; break ;
430 case GB_FP64_code : op = GxB_RMINUS_FP64 ; break ;
431 case GB_FC32_code : op = GxB_RMINUS_FC32 ; break ;
432 case GB_FC64_code : op = GxB_RMINUS_FC64 ; break ;
433 default :
434 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
435 return (false) ;
436 }
437 break ;
438
439 case GB_TIMES_opcode :
440
441 switch (xcode)
442 {
443 case GB_BOOL_code : op = GrB_TIMES_BOOL ; break ;
444 case GB_INT8_code : op = GrB_TIMES_INT8 ; break ;
445 case GB_INT16_code : op = GrB_TIMES_INT16 ; break ;
446 case GB_INT32_code : op = GrB_TIMES_INT32 ; break ;
447 case GB_INT64_code : op = GrB_TIMES_INT64 ; break ;
448 case GB_UINT8_code : op = GrB_TIMES_UINT8 ; break ;
449 case GB_UINT16_code : op = GrB_TIMES_UINT16 ; break ;
450 case GB_UINT32_code : op = GrB_TIMES_UINT32 ; break ;
451 case GB_UINT64_code : op = GrB_TIMES_UINT64 ; break ;
452 case GB_FP32_code : op = GrB_TIMES_FP32 ; break ;
453 case GB_FP64_code : op = GrB_TIMES_FP64 ; break ;
454 case GB_FC32_code : op = GxB_TIMES_FC32 ; break ;
455 case GB_FC64_code : op = GxB_TIMES_FC64 ; break ;
456 default :
457 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
458 return (false) ;
459 }
460 break ;
461
462 case GB_DIV_opcode :
463
464 switch (xcode)
465 {
466 case GB_BOOL_code : op = GrB_DIV_BOOL ; break ;
467 case GB_INT8_code : op = GrB_DIV_INT8 ; break ;
468 case GB_INT16_code : op = GrB_DIV_INT16 ; break ;
469 case GB_INT32_code : op = GrB_DIV_INT32 ; break ;
470 case GB_INT64_code : op = GrB_DIV_INT64 ; break ;
471 case GB_UINT8_code : op = GrB_DIV_UINT8 ; break ;
472 case GB_UINT16_code : op = GrB_DIV_UINT16 ; break ;
473 case GB_UINT32_code : op = GrB_DIV_UINT32 ; break ;
474 case GB_UINT64_code : op = GrB_DIV_UINT64 ; break ;
475 case GB_FP32_code : op = GrB_DIV_FP32 ; break ;
476 case GB_FP64_code : op = GrB_DIV_FP64 ; break ;
477 case GB_FC32_code : op = GxB_DIV_FC32 ; break ;
478 case GB_FC64_code : op = GxB_DIV_FC64 ; break ;
479 default :
480 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
481 return (false) ;
482 }
483 break ;
484
485 case GB_RDIV_opcode :
486
487 switch (xcode)
488 {
489 case GB_BOOL_code : op = GxB_RDIV_BOOL ; break ;
490 case GB_INT8_code : op = GxB_RDIV_INT8 ; break ;
491 case GB_INT16_code : op = GxB_RDIV_INT16 ; break ;
492 case GB_INT32_code : op = GxB_RDIV_INT32 ; break ;
493 case GB_INT64_code : op = GxB_RDIV_INT64 ; break ;
494 case GB_UINT8_code : op = GxB_RDIV_UINT8 ; break ;
495 case GB_UINT16_code : op = GxB_RDIV_UINT16 ; break ;
496 case GB_UINT32_code : op = GxB_RDIV_UINT32 ; break ;
497 case GB_UINT64_code : op = GxB_RDIV_UINT64 ; break ;
498 case GB_FP32_code : op = GxB_RDIV_FP32 ; break ;
499 case GB_FP64_code : op = GxB_RDIV_FP64 ; break ;
500 case GB_FC32_code : op = GxB_RDIV_FC32 ; break ;
501 case GB_FC64_code : op = GxB_RDIV_FC64 ; break ;
502 default :
503 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
504 return (false) ;
505 }
506 break ;
507
508 case GB_POW_opcode : // z = pow (x,y)
509
510 switch (xcode)
511 {
512 case GB_BOOL_code : op = GxB_POW_BOOL ; break ;
513 case GB_INT8_code : op = GxB_POW_INT8 ; break ;
514 case GB_INT16_code : op = GxB_POW_INT16 ; break ;
515 case GB_INT32_code : op = GxB_POW_INT32 ; break ;
516 case GB_INT64_code : op = GxB_POW_INT64 ; break ;
517 case GB_UINT8_code : op = GxB_POW_UINT8 ; break ;
518 case GB_UINT16_code : op = GxB_POW_UINT16 ; break ;
519 case GB_UINT32_code : op = GxB_POW_UINT32 ; break ;
520 case GB_UINT64_code : op = GxB_POW_UINT64 ; break ;
521 case GB_FP32_code : op = GxB_POW_FP32 ; break ;
522 case GB_FP64_code : op = GxB_POW_FP64 ; break ;
523 case GB_FC32_code : op = GxB_POW_FC32 ; break ;
524 case GB_FC64_code : op = GxB_POW_FC64 ; break ;
525 default :
526 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
527 return (false) ;
528 }
529 break ;
530
531 case GB_ISEQ_opcode :
532
533 switch (xcode)
534 {
535 case GB_BOOL_code : op = GxB_ISEQ_BOOL ; break ;
536 case GB_INT8_code : op = GxB_ISEQ_INT8 ; break ;
537 case GB_INT16_code : op = GxB_ISEQ_INT16 ; break ;
538 case GB_INT32_code : op = GxB_ISEQ_INT32 ; break ;
539 case GB_INT64_code : op = GxB_ISEQ_INT64 ; break ;
540 case GB_UINT8_code : op = GxB_ISEQ_UINT8 ; break ;
541 case GB_UINT16_code : op = GxB_ISEQ_UINT16 ; break ;
542 case GB_UINT32_code : op = GxB_ISEQ_UINT32 ; break ;
543 case GB_UINT64_code : op = GxB_ISEQ_UINT64 ; break ;
544 case GB_FP32_code : op = GxB_ISEQ_FP32 ; break ;
545 case GB_FP64_code : op = GxB_ISEQ_FP64 ; break ;
546 case GB_FC32_code : op = GxB_ISEQ_FC32 ; break ;
547 case GB_FC64_code : op = GxB_ISEQ_FC64 ; break ;
548 default :
549 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
550 return (false) ;
551 }
552 break ;
553
554 case GB_ISNE_opcode :
555
556 switch (xcode)
557 {
558 case GB_BOOL_code : op = GxB_ISNE_BOOL ; break ;
559 case GB_INT8_code : op = GxB_ISNE_INT8 ; break ;
560 case GB_INT16_code : op = GxB_ISNE_INT16 ; break ;
561 case GB_INT32_code : op = GxB_ISNE_INT32 ; break ;
562 case GB_INT64_code : op = GxB_ISNE_INT64 ; break ;
563 case GB_UINT8_code : op = GxB_ISNE_UINT8 ; break ;
564 case GB_UINT16_code : op = GxB_ISNE_UINT16 ; break ;
565 case GB_UINT32_code : op = GxB_ISNE_UINT32 ; break ;
566 case GB_UINT64_code : op = GxB_ISNE_UINT64 ; break ;
567 case GB_FP32_code : op = GxB_ISNE_FP32 ; break ;
568 case GB_FP64_code : op = GxB_ISNE_FP64 ; break ;
569 case GB_FC32_code : op = GxB_ISNE_FC32 ; break ;
570 case GB_FC64_code : op = GxB_ISNE_FC64 ; break ;
571 default :
572 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
573 return (false) ;
574 }
575 break ;
576
577 case GB_ISGT_opcode :
578
579 switch (xcode)
580 {
581 case GB_BOOL_code : op = GxB_ISGT_BOOL ; break ;
582 case GB_INT8_code : op = GxB_ISGT_INT8 ; break ;
583 case GB_INT16_code : op = GxB_ISGT_INT16 ; break ;
584 case GB_INT32_code : op = GxB_ISGT_INT32 ; break ;
585 case GB_INT64_code : op = GxB_ISGT_INT64 ; break ;
586 case GB_UINT8_code : op = GxB_ISGT_UINT8 ; break ;
587 case GB_UINT16_code : op = GxB_ISGT_UINT16 ; break ;
588 case GB_UINT32_code : op = GxB_ISGT_UINT32 ; break ;
589 case GB_UINT64_code : op = GxB_ISGT_UINT64 ; break ;
590 case GB_FP32_code : op = GxB_ISGT_FP32 ; break ;
591 case GB_FP64_code : op = GxB_ISGT_FP64 ; break ;
592 default :
593 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
594 return (false) ;
595 }
596 break ;
597
598 case GB_ISLT_opcode :
599
600 switch (xcode)
601 {
602 case GB_BOOL_code : op = GxB_ISLT_BOOL ; break ;
603 case GB_INT8_code : op = GxB_ISLT_INT8 ; break ;
604 case GB_INT16_code : op = GxB_ISLT_INT16 ; break ;
605 case GB_INT32_code : op = GxB_ISLT_INT32 ; break ;
606 case GB_INT64_code : op = GxB_ISLT_INT64 ; break ;
607 case GB_UINT8_code : op = GxB_ISLT_UINT8 ; break ;
608 case GB_UINT16_code : op = GxB_ISLT_UINT16 ; break ;
609 case GB_UINT32_code : op = GxB_ISLT_UINT32 ; break ;
610 case GB_UINT64_code : op = GxB_ISLT_UINT64 ; break ;
611 case GB_FP32_code : op = GxB_ISLT_FP32 ; break ;
612 case GB_FP64_code : op = GxB_ISLT_FP64 ; break ;
613 default :
614 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
615 return (false) ;
616 }
617 break ;
618
619 case GB_ISGE_opcode :
620
621 switch (xcode)
622 {
623 case GB_BOOL_code : op = GxB_ISGE_BOOL ; break ;
624 case GB_INT8_code : op = GxB_ISGE_INT8 ; break ;
625 case GB_INT16_code : op = GxB_ISGE_INT16 ; break ;
626 case GB_INT32_code : op = GxB_ISGE_INT32 ; break ;
627 case GB_INT64_code : op = GxB_ISGE_INT64 ; break ;
628 case GB_UINT8_code : op = GxB_ISGE_UINT8 ; break ;
629 case GB_UINT16_code : op = GxB_ISGE_UINT16 ; break ;
630 case GB_UINT32_code : op = GxB_ISGE_UINT32 ; break ;
631 case GB_UINT64_code : op = GxB_ISGE_UINT64 ; break ;
632 case GB_FP32_code : op = GxB_ISGE_FP32 ; break ;
633 case GB_FP64_code : op = GxB_ISGE_FP64 ; break ;
634 default :
635 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
636 return (false) ;
637 }
638 break ;
639
640 case GB_ISLE_opcode :
641
642 switch (xcode)
643 {
644 case GB_BOOL_code : op = GxB_ISLE_BOOL ; break ;
645 case GB_INT8_code : op = GxB_ISLE_INT8 ; break ;
646 case GB_INT16_code : op = GxB_ISLE_INT16 ; break ;
647 case GB_INT32_code : op = GxB_ISLE_INT32 ; break ;
648 case GB_INT64_code : op = GxB_ISLE_INT64 ; break ;
649 case GB_UINT8_code : op = GxB_ISLE_UINT8 ; break ;
650 case GB_UINT16_code : op = GxB_ISLE_UINT16 ; break ;
651 case GB_UINT32_code : op = GxB_ISLE_UINT32 ; break ;
652 case GB_UINT64_code : op = GxB_ISLE_UINT64 ; break ;
653 case GB_FP32_code : op = GxB_ISLE_FP32 ; break ;
654 case GB_FP64_code : op = GxB_ISLE_FP64 ; break ;
655 default :
656 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
657 return (false) ;
658 }
659 break ;
660
661
662 case GB_EQ_opcode :
663
664 switch (xcode)
665 {
666 case GB_BOOL_code : op = GrB_EQ_BOOL ; break ;
667 case GB_INT8_code : op = GrB_EQ_INT8 ; break ;
668 case GB_INT16_code : op = GrB_EQ_INT16 ; break ;
669 case GB_INT32_code : op = GrB_EQ_INT32 ; break ;
670 case GB_INT64_code : op = GrB_EQ_INT64 ; break ;
671 case GB_UINT8_code : op = GrB_EQ_UINT8 ; break ;
672 case GB_UINT16_code : op = GrB_EQ_UINT16 ; break ;
673 case GB_UINT32_code : op = GrB_EQ_UINT32 ; break ;
674 case GB_UINT64_code : op = GrB_EQ_UINT64 ; break ;
675 case GB_FP32_code : op = GrB_EQ_FP32 ; break ;
676 case GB_FP64_code : op = GrB_EQ_FP64 ; break ;
677 case GB_FC32_code : op = GxB_EQ_FC32 ; break ;
678 case GB_FC64_code : op = GxB_EQ_FC64 ; break ;
679 default :
680 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
681 return (false) ;
682 }
683 break ;
684
685 case GB_NE_opcode :
686
687 switch (xcode)
688 {
689 case GB_BOOL_code : op = GrB_NE_BOOL ; break ;
690 case GB_INT8_code : op = GrB_NE_INT8 ; break ;
691 case GB_INT16_code : op = GrB_NE_INT16 ; break ;
692 case GB_INT32_code : op = GrB_NE_INT32 ; break ;
693 case GB_INT64_code : op = GrB_NE_INT64 ; break ;
694 case GB_UINT8_code : op = GrB_NE_UINT8 ; break ;
695 case GB_UINT16_code : op = GrB_NE_UINT16 ; break ;
696 case GB_UINT32_code : op = GrB_NE_UINT32 ; break ;
697 case GB_UINT64_code : op = GrB_NE_UINT64 ; break ;
698 case GB_FP32_code : op = GrB_NE_FP32 ; break ;
699 case GB_FP64_code : op = GrB_NE_FP64 ; break ;
700 case GB_FC32_code : op = GxB_NE_FC32 ; break ;
701 case GB_FC64_code : op = GxB_NE_FC64 ; break ;
702 default :
703 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
704 return (false) ;
705 }
706 break ;
707
708 case GB_GT_opcode :
709
710 switch (xcode)
711 {
712 case GB_BOOL_code : op = GrB_GT_BOOL ; break ;
713 case GB_INT8_code : op = GrB_GT_INT8 ; break ;
714 case GB_INT16_code : op = GrB_GT_INT16 ; break ;
715 case GB_INT32_code : op = GrB_GT_INT32 ; break ;
716 case GB_INT64_code : op = GrB_GT_INT64 ; break ;
717 case GB_UINT8_code : op = GrB_GT_UINT8 ; break ;
718 case GB_UINT16_code : op = GrB_GT_UINT16 ; break ;
719 case GB_UINT32_code : op = GrB_GT_UINT32 ; break ;
720 case GB_UINT64_code : op = GrB_GT_UINT64 ; break ;
721 case GB_FP32_code : op = GrB_GT_FP32 ; break ;
722 case GB_FP64_code : op = GrB_GT_FP64 ; break ;
723 default :
724 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
725 return (false) ;
726 }
727 break ;
728
729 case GB_LT_opcode :
730
731 switch (xcode)
732 {
733 case GB_BOOL_code : op = GrB_LT_BOOL ; break ;
734 case GB_INT8_code : op = GrB_LT_INT8 ; break ;
735 case GB_INT16_code : op = GrB_LT_INT16 ; break ;
736 case GB_INT32_code : op = GrB_LT_INT32 ; break ;
737 case GB_INT64_code : op = GrB_LT_INT64 ; break ;
738 case GB_UINT8_code : op = GrB_LT_UINT8 ; break ;
739 case GB_UINT16_code : op = GrB_LT_UINT16 ; break ;
740 case GB_UINT32_code : op = GrB_LT_UINT32 ; break ;
741 case GB_UINT64_code : op = GrB_LT_UINT64 ; break ;
742 case GB_FP32_code : op = GrB_LT_FP32 ; break ;
743 case GB_FP64_code : op = GrB_LT_FP64 ; break ;
744 default :
745 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
746 return (false) ;
747 }
748 break ;
749
750 case GB_GE_opcode :
751
752 switch (xcode)
753 {
754 case GB_BOOL_code : op = GrB_GE_BOOL ; break ;
755 case GB_INT8_code : op = GrB_GE_INT8 ; break ;
756 case GB_INT16_code : op = GrB_GE_INT16 ; break ;
757 case GB_INT32_code : op = GrB_GE_INT32 ; break ;
758 case GB_INT64_code : op = GrB_GE_INT64 ; break ;
759 case GB_UINT8_code : op = GrB_GE_UINT8 ; break ;
760 case GB_UINT16_code : op = GrB_GE_UINT16 ; break ;
761 case GB_UINT32_code : op = GrB_GE_UINT32 ; break ;
762 case GB_UINT64_code : op = GrB_GE_UINT64 ; break ;
763 case GB_FP32_code : op = GrB_GE_FP32 ; break ;
764 case GB_FP64_code : op = GrB_GE_FP64 ; break ;
765 default :
766 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
767 return (false) ;
768 }
769 break ;
770
771 case GB_LE_opcode :
772
773 switch (xcode)
774 {
775 case GB_BOOL_code : op = GrB_LE_BOOL ; break ;
776 case GB_INT8_code : op = GrB_LE_INT8 ; break ;
777 case GB_INT16_code : op = GrB_LE_INT16 ; break ;
778 case GB_INT32_code : op = GrB_LE_INT32 ; break ;
779 case GB_INT64_code : op = GrB_LE_INT64 ; break ;
780 case GB_UINT8_code : op = GrB_LE_UINT8 ; break ;
781 case GB_UINT16_code : op = GrB_LE_UINT16 ; break ;
782 case GB_UINT32_code : op = GrB_LE_UINT32 ; break ;
783 case GB_UINT64_code : op = GrB_LE_UINT64 ; break ;
784 case GB_FP32_code : op = GrB_LE_FP32 ; break ;
785 case GB_FP64_code : op = GrB_LE_FP64 ; break ;
786 default :
787 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
788 return (false) ;
789 }
790 break ;
791
792
793 case GB_LOR_opcode :
794
795 switch (xcode)
796 {
797 case GB_BOOL_code : op = GrB_LOR ; break ;
798 case GB_INT8_code : op = GxB_LOR_INT8 ; break ;
799 case GB_INT16_code : op = GxB_LOR_INT16 ; break ;
800 case GB_INT32_code : op = GxB_LOR_INT32 ; break ;
801 case GB_INT64_code : op = GxB_LOR_INT64 ; break ;
802 case GB_UINT8_code : op = GxB_LOR_UINT8 ; break ;
803 case GB_UINT16_code : op = GxB_LOR_UINT16 ; break ;
804 case GB_UINT32_code : op = GxB_LOR_UINT32 ; break ;
805 case GB_UINT64_code : op = GxB_LOR_UINT64 ; break ;
806 case GB_FP32_code : op = GxB_LOR_FP32 ; break ;
807 case GB_FP64_code : op = GxB_LOR_FP64 ; break ;
808 default :
809 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
810 return (false) ;
811 }
812 break ;
813
814 case GB_LAND_opcode :
815
816 switch (xcode)
817 {
818 case GB_BOOL_code : op = GrB_LAND ; break ;
819 case GB_INT8_code : op = GxB_LAND_INT8 ; break ;
820 case GB_INT16_code : op = GxB_LAND_INT16 ; break ;
821 case GB_INT32_code : op = GxB_LAND_INT32 ; break ;
822 case GB_INT64_code : op = GxB_LAND_INT64 ; break ;
823 case GB_UINT8_code : op = GxB_LAND_UINT8 ; break ;
824 case GB_UINT16_code : op = GxB_LAND_UINT16 ; break ;
825 case GB_UINT32_code : op = GxB_LAND_UINT32 ; break ;
826 case GB_UINT64_code : op = GxB_LAND_UINT64 ; break ;
827 case GB_FP32_code : op = GxB_LAND_FP32 ; break ;
828 case GB_FP64_code : op = GxB_LAND_FP64 ; break ;
829 default :
830 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
831 return (false) ;
832 }
833 break ;
834
835 case GB_LXOR_opcode :
836
837 switch (xcode)
838 {
839 case GB_BOOL_code : op = GrB_LXOR ; break ;
840 case GB_INT8_code : op = GxB_LXOR_INT8 ; break ;
841 case GB_INT16_code : op = GxB_LXOR_INT16 ; break ;
842 case GB_INT32_code : op = GxB_LXOR_INT32 ; break ;
843 case GB_INT64_code : op = GxB_LXOR_INT64 ; break ;
844 case GB_UINT8_code : op = GxB_LXOR_UINT8 ; break ;
845 case GB_UINT16_code : op = GxB_LXOR_UINT16 ; break ;
846 case GB_UINT32_code : op = GxB_LXOR_UINT32 ; break ;
847 case GB_UINT64_code : op = GxB_LXOR_UINT64 ; break ;
848 case GB_FP32_code : op = GxB_LXOR_FP32 ; break ;
849 case GB_FP64_code : op = GxB_LXOR_FP64 ; break ;
850 default :
851 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
852 return (false) ;
853 }
854 break ;
855
856 case GB_ATAN2_opcode : // z = atan2 (x,y)
857
858 switch (xcode)
859 {
860 case GB_FP32_code : op = GxB_ATAN2_FP32 ; break ;
861 case GB_FP64_code : op = GxB_ATAN2_FP64 ; break ;
862 default :
863 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
864 return (false) ;
865 }
866 break ;
867
868 case GB_HYPOT_opcode : // z = hypot (x,y)
869
870 switch (xcode)
871 {
872 case GB_FP32_code : op = GxB_HYPOT_FP32 ; break ;
873 case GB_FP64_code : op = GxB_HYPOT_FP64 ; break ;
874 default :
875 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
876 return (false) ;
877 }
878 break ;
879
880 case GB_FMOD_opcode : // z = fmod (x,y)
881
882 switch (xcode)
883 {
884 case GB_FP32_code : op = GxB_FMOD_FP32 ; break ;
885 case GB_FP64_code : op = GxB_FMOD_FP64 ; break ;
886 default :
887 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
888 return (false) ;
889 }
890 break ;
891
892 case GB_REMAINDER_opcode : // z = remainder (x,y)
893
894 switch (xcode)
895 {
896 case GB_FP32_code : op = GxB_REMAINDER_FP32 ; break ;
897 case GB_FP64_code : op = GxB_REMAINDER_FP64 ; break ;
898 default :
899 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
900 return (false) ;
901 }
902 break ;
903
904 case GB_COPYSIGN_opcode : // z = copysign (x,y)
905
906 switch (xcode)
907 {
908 case GB_FP32_code : op = GxB_COPYSIGN_FP32 ; break ;
909 case GB_FP64_code : op = GxB_COPYSIGN_FP64 ; break ;
910 default :
911 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
912 return (false) ;
913 }
914 break ;
915
916 case GB_LDEXP_opcode : // z = ldexp (x,y)
917
918 switch (xcode)
919 {
920 case GB_FP32_code : op = GxB_LDEXP_FP32 ; break ;
921 case GB_FP64_code : op = GxB_LDEXP_FP64 ; break ;
922 default :
923 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
924 return (false) ;
925 }
926 break ;
927
928 case GB_CMPLX_opcode : // z = cmplx (x,y)
929
930 switch (xcode)
931 {
932 case GB_FP32_code : op = GxB_CMPLX_FP32 ; break ;
933 case GB_FP64_code : op = GxB_CMPLX_FP64 ; break ;
934 default :
935 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
936 return (false) ;
937 }
938 break ;
939
940 case GB_BOR_opcode : // z = (x | y), bitwise or
941
942 switch (xcode)
943 {
944 case GB_INT8_code : op = GrB_BOR_INT8 ; break ;
945 case GB_INT16_code : op = GrB_BOR_INT16 ; break ;
946 case GB_INT32_code : op = GrB_BOR_INT32 ; break ;
947 case GB_INT64_code : op = GrB_BOR_INT64 ; break ;
948 case GB_UINT8_code : op = GrB_BOR_UINT8 ; break ;
949 case GB_UINT16_code : op = GrB_BOR_UINT16 ; break ;
950 case GB_UINT32_code : op = GrB_BOR_UINT32 ; break ;
951 case GB_UINT64_code : op = GrB_BOR_UINT64 ; break ;
952 default :
953 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
954 return (false) ;
955 }
956 break ;
957
958 case GB_BAND_opcode : // z = (x & y), bitwise and
959
960 switch (xcode)
961 {
962 case GB_INT8_code : op = GrB_BAND_INT8 ; break ;
963 case GB_INT16_code : op = GrB_BAND_INT16 ; break ;
964 case GB_INT32_code : op = GrB_BAND_INT32 ; break ;
965 case GB_INT64_code : op = GrB_BAND_INT64 ; break ;
966 case GB_UINT8_code : op = GrB_BAND_UINT8 ; break ;
967 case GB_UINT16_code : op = GrB_BAND_UINT16 ; break ;
968 case GB_UINT32_code : op = GrB_BAND_UINT32 ; break ;
969 case GB_UINT64_code : op = GrB_BAND_UINT64 ; break ;
970 default :
971 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
972 return (false) ;
973 }
974 break ;
975
976 case GB_BXOR_opcode : // z = (x ^ y), bitwise xor
977
978 switch (xcode)
979 {
980 case GB_INT8_code : op = GrB_BXOR_INT8 ; break ;
981 case GB_INT16_code : op = GrB_BXOR_INT16 ; break ;
982 case GB_INT32_code : op = GrB_BXOR_INT32 ; break ;
983 case GB_INT64_code : op = GrB_BXOR_INT64 ; break ;
984 case GB_UINT8_code : op = GrB_BXOR_UINT8 ; break ;
985 case GB_UINT16_code : op = GrB_BXOR_UINT16 ; break ;
986 case GB_UINT32_code : op = GrB_BXOR_UINT32 ; break ;
987 case GB_UINT64_code : op = GrB_BXOR_UINT64 ; break ;
988 default :
989 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
990 return (false) ;
991 }
992 break ;
993
994 case GB_BXNOR_opcode : // z = ~(x ^ y), bitwise xnor
995
996 switch (xcode)
997 {
998 case GB_INT8_code : op = GrB_BXNOR_INT8 ; break ;
999 case GB_INT16_code : op = GrB_BXNOR_INT16 ; break ;
1000 case GB_INT32_code : op = GrB_BXNOR_INT32 ; break ;
1001 case GB_INT64_code : op = GrB_BXNOR_INT64 ; break ;
1002 case GB_UINT8_code : op = GrB_BXNOR_UINT8 ; break ;
1003 case GB_UINT16_code : op = GrB_BXNOR_UINT16 ; break ;
1004 case GB_UINT32_code : op = GrB_BXNOR_UINT32 ; break ;
1005 case GB_UINT64_code : op = GrB_BXNOR_UINT64 ; break ;
1006 default :
1007 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
1008 return (false) ;
1009 }
1010 break ;
1011
1012 case GB_BGET_opcode : // z = bitget (x,y)
1013
1014 switch (xcode)
1015 {
1016 case GB_INT8_code : op = GxB_BGET_INT8 ; break ;
1017 case GB_INT16_code : op = GxB_BGET_INT16 ; break ;
1018 case GB_INT32_code : op = GxB_BGET_INT32 ; break ;
1019 case GB_INT64_code : op = GxB_BGET_INT64 ; break ;
1020 case GB_UINT8_code : op = GxB_BGET_UINT8 ; break ;
1021 case GB_UINT16_code : op = GxB_BGET_UINT16 ; break ;
1022 case GB_UINT32_code : op = GxB_BGET_UINT32 ; break ;
1023 case GB_UINT64_code : op = GxB_BGET_UINT64 ; break ;
1024 default :
1025 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
1026 return (false) ;
1027 }
1028 break ;
1029
1030 case GB_BSET_opcode : // z = bitset (x,y)
1031
1032 switch (xcode)
1033 {
1034 case GB_INT8_code : op = GxB_BSET_INT8 ; break ;
1035 case GB_INT16_code : op = GxB_BSET_INT16 ; break ;
1036 case GB_INT32_code : op = GxB_BSET_INT32 ; break ;
1037 case GB_INT64_code : op = GxB_BSET_INT64 ; break ;
1038 case GB_UINT8_code : op = GxB_BSET_UINT8 ; break ;
1039 case GB_UINT16_code : op = GxB_BSET_UINT16 ; break ;
1040 case GB_UINT32_code : op = GxB_BSET_UINT32 ; break ;
1041 case GB_UINT64_code : op = GxB_BSET_UINT64 ; break ;
1042 default :
1043 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
1044 return (false) ;
1045 }
1046 break ;
1047
1048 case GB_BCLR_opcode : // z = bitclr (x,y)
1049
1050 switch (xcode)
1051 {
1052 case GB_INT8_code : op = GxB_BCLR_INT8 ; break ;
1053 case GB_INT16_code : op = GxB_BCLR_INT16 ; break ;
1054 case GB_INT32_code : op = GxB_BCLR_INT32 ; break ;
1055 case GB_INT64_code : op = GxB_BCLR_INT64 ; break ;
1056 case GB_UINT8_code : op = GxB_BCLR_UINT8 ; break ;
1057 case GB_UINT16_code : op = GxB_BCLR_UINT16 ; break ;
1058 case GB_UINT32_code : op = GxB_BCLR_UINT32 ; break ;
1059 case GB_UINT64_code : op = GxB_BCLR_UINT64 ; break ;
1060 default :
1061 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
1062 return (false) ;
1063 }
1064 break ;
1065
1066 case GB_BSHIFT_opcode : // z = bitshift (x,y)
1067
1068 switch (xcode)
1069 {
1070 case GB_INT8_code : op = GxB_BSHIFT_INT8 ; break ;
1071 case GB_INT16_code : op = GxB_BSHIFT_INT16 ; break ;
1072 case GB_INT32_code : op = GxB_BSHIFT_INT32 ; break ;
1073 case GB_INT64_code : op = GxB_BSHIFT_INT64 ; break ;
1074 case GB_UINT8_code : op = GxB_BSHIFT_UINT8 ; break ;
1075 case GB_UINT16_code : op = GxB_BSHIFT_UINT16 ; break ;
1076 case GB_UINT32_code : op = GxB_BSHIFT_UINT32 ; break ;
1077 case GB_UINT64_code : op = GxB_BSHIFT_UINT64 ; break ;
1078 default :
1079 mexWarnMsgIdAndTxt ("GB:warn","unknown operator") ;
1080 return (false) ;
1081 }
1082 break ;
1083
1084 case GB_FIRSTI_opcode : op = is64 ? GxB_FIRSTI_INT64 : GxB_FIRSTI_INT32 ; break ;
1085 case GB_FIRSTI1_opcode : op = is64 ? GxB_FIRSTI1_INT64 : GxB_FIRSTI1_INT32 ; break ;
1086 case GB_FIRSTJ_opcode : op = is64 ? GxB_FIRSTJ_INT64 : GxB_FIRSTJ_INT32 ; break ;
1087 case GB_FIRSTJ1_opcode : op = is64 ? GxB_FIRSTJ1_INT64 : GxB_FIRSTJ1_INT32 ; break ;
1088 case GB_SECONDI_opcode : op = is64 ? GxB_SECONDI_INT64 : GxB_SECONDI_INT32 ; break ;
1089 case GB_SECONDI1_opcode : op = is64 ? GxB_SECONDI1_INT64 : GxB_SECONDI1_INT32 ; break ;
1090 case GB_SECONDJ_opcode : op = is64 ? GxB_SECONDJ_INT64 : GxB_SECONDJ_INT32 ; break ;
1091 case GB_SECONDJ1_opcode : op = is64 ? GxB_SECONDJ1_INT64 : GxB_SECONDJ1_INT32 ; break ;
1092
1093 default :
1094 mexWarnMsgIdAndTxt ("GB:warn","unknown binary operator") ;
1095 return (false) ;
1096 }
1097 }
1098
1099 //--------------------------------------------------------------------------
1100 // return result
1101 //--------------------------------------------------------------------------
1102
1103 // return the binary operator to the caller
1104 ASSERT_BINARYOP_OK_OR_NULL (op, "got binary op", GB0) ;
1105 (*op_handle) = op ;
1106 return (true) ;
1107 }
1108
1109