1 //------------------------------------------------------------------------------
2 // gb_string_and_type_to_binop: get a GraphBLAS operator from a string and type
3 //------------------------------------------------------------------------------
4
5 // SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
6 // SPDX-License-Identifier: GPL-3.0-or-later
7
8 //------------------------------------------------------------------------------
9
10 #include "gb_matlab.h"
11
12 // op_name: a MATLAB string defining the operator name:
13 // 1st, 2nd, pair, min, max, +, -, rminus, *, /, \
14 // iseq, isne, isgt, islt, isge, isle,
15 // ==, ~=, >, <, >=, <=,
16 // ||, &&, xor
17 // atan2, hypot, fmod, remainder, copysign, cmplx, pow, pow2
18
19 // bitwise operators:
20 // bitand, bitor, bitxor, bitxnor, bitget, bitset, bitclr, bitshift
21
22 // positional operators:
23 // firsti0, firsti1, firstj0, firstj1, secondi0, secondi1, secondj0,
24 // secondj1. The default type is int64
25
26 // The following synonyms are allowed for specifying these operators:
27 //
28 // 1st first
29 // 2nd second
30 // pair
31 // + plus
32 // - minus
33 // * times
34 // / div
35 // \ rdiv
36 // == eq
37 // ~= ne
38 // > gt
39 // < lt
40 // >= ge
41 // <= le
42 // || | or lor
43 // && & and land
44 // xor lxor
45 // pow2 ldexp
46
gb_string_and_type_to_binop(const char * op_name,const GrB_Type type,const bool type_not_given)47 GrB_BinaryOp gb_string_and_type_to_binop // return op from string and type
48 (
49 const char *op_name, // name of the operator, as a string
50 const GrB_Type type, // type of the x,y inputs to the operator
51 const bool type_not_given // true if no type present in the string
52 )
53 {
54
55 if (MATCH (op_name, "1st") || MATCH (op_name, "first"))
56 {
57
58 if (type == GrB_BOOL ) return (GrB_FIRST_BOOL ) ;
59 if (type == GrB_INT8 ) return (GrB_FIRST_INT8 ) ;
60 if (type == GrB_INT16 ) return (GrB_FIRST_INT16 ) ;
61 if (type == GrB_INT32 ) return (GrB_FIRST_INT32 ) ;
62 if (type == GrB_INT64 ) return (GrB_FIRST_INT64 ) ;
63 if (type == GrB_UINT8 ) return (GrB_FIRST_UINT8 ) ;
64 if (type == GrB_UINT16) return (GrB_FIRST_UINT16) ;
65 if (type == GrB_UINT32) return (GrB_FIRST_UINT32) ;
66 if (type == GrB_UINT64) return (GrB_FIRST_UINT64) ;
67 if (type == GrB_FP32 ) return (GrB_FIRST_FP32 ) ;
68 if (type == GrB_FP64 ) return (GrB_FIRST_FP64 ) ;
69 if (type == GxB_FC32 ) return (GxB_FIRST_FC32 ) ;
70 if (type == GxB_FC64 ) return (GxB_FIRST_FC64 ) ;
71
72 }
73 else if (MATCH (op_name, "2nd") || MATCH (op_name, "second"))
74 {
75
76 if (type == GrB_BOOL ) return (GrB_SECOND_BOOL ) ;
77 if (type == GrB_INT8 ) return (GrB_SECOND_INT8 ) ;
78 if (type == GrB_INT16 ) return (GrB_SECOND_INT16 ) ;
79 if (type == GrB_INT32 ) return (GrB_SECOND_INT32 ) ;
80 if (type == GrB_INT64 ) return (GrB_SECOND_INT64 ) ;
81 if (type == GrB_UINT8 ) return (GrB_SECOND_UINT8 ) ;
82 if (type == GrB_UINT16) return (GrB_SECOND_UINT16) ;
83 if (type == GrB_UINT32) return (GrB_SECOND_UINT32) ;
84 if (type == GrB_UINT64) return (GrB_SECOND_UINT64) ;
85 if (type == GrB_FP32 ) return (GrB_SECOND_FP32 ) ;
86 if (type == GrB_FP64 ) return (GrB_SECOND_FP64 ) ;
87 if (type == GxB_FC32 ) return (GxB_SECOND_FC32 ) ;
88 if (type == GxB_FC64 ) return (GxB_SECOND_FC64 ) ;
89
90 }
91 else if (MATCH (op_name, "any"))
92 {
93
94 if (type == GrB_BOOL ) return (GxB_ANY_BOOL ) ;
95 if (type == GrB_INT8 ) return (GxB_ANY_INT8 ) ;
96 if (type == GrB_INT16 ) return (GxB_ANY_INT16 ) ;
97 if (type == GrB_INT32 ) return (GxB_ANY_INT32 ) ;
98 if (type == GrB_INT64 ) return (GxB_ANY_INT64 ) ;
99 if (type == GrB_UINT8 ) return (GxB_ANY_UINT8 ) ;
100 if (type == GrB_UINT16) return (GxB_ANY_UINT16) ;
101 if (type == GrB_UINT32) return (GxB_ANY_UINT32) ;
102 if (type == GrB_UINT64) return (GxB_ANY_UINT64) ;
103 if (type == GrB_FP32 ) return (GxB_ANY_FP32 ) ;
104 if (type == GrB_FP64 ) return (GxB_ANY_FP64 ) ;
105 if (type == GxB_FC32 ) return (GxB_ANY_FC32 ) ;
106 if (type == GxB_FC64 ) return (GxB_ANY_FC64 ) ;
107
108 }
109 else if (MATCH (op_name, "pair"))
110 {
111
112 if (type == GrB_BOOL ) return (GxB_PAIR_BOOL ) ;
113 if (type == GrB_INT8 ) return (GxB_PAIR_INT8 ) ;
114 if (type == GrB_INT16 ) return (GxB_PAIR_INT16 ) ;
115 if (type == GrB_INT32 ) return (GxB_PAIR_INT32 ) ;
116 if (type == GrB_INT64 ) return (GxB_PAIR_INT64 ) ;
117 if (type == GrB_UINT8 ) return (GxB_PAIR_UINT8 ) ;
118 if (type == GrB_UINT16) return (GxB_PAIR_UINT16) ;
119 if (type == GrB_UINT32) return (GxB_PAIR_UINT32) ;
120 if (type == GrB_UINT64) return (GxB_PAIR_UINT64) ;
121 if (type == GrB_FP32 ) return (GxB_PAIR_FP32 ) ;
122 if (type == GrB_FP64 ) return (GxB_PAIR_FP64 ) ;
123 if (type == GxB_FC32 ) return (GxB_PAIR_FC32 ) ;
124 if (type == GxB_FC64 ) return (GxB_PAIR_FC64 ) ;
125
126 }
127 else if (MATCH (op_name, "min"))
128 {
129
130 if (type == GrB_BOOL ) return (GrB_MIN_BOOL ) ;
131 if (type == GrB_INT8 ) return (GrB_MIN_INT8 ) ;
132 if (type == GrB_INT16 ) return (GrB_MIN_INT16 ) ;
133 if (type == GrB_INT32 ) return (GrB_MIN_INT32 ) ;
134 if (type == GrB_INT64 ) return (GrB_MIN_INT64 ) ;
135 if (type == GrB_UINT8 ) return (GrB_MIN_UINT8 ) ;
136 if (type == GrB_UINT16) return (GrB_MIN_UINT16) ;
137 if (type == GrB_UINT32) return (GrB_MIN_UINT32) ;
138 if (type == GrB_UINT64) return (GrB_MIN_UINT64) ;
139 if (type == GrB_FP32 ) return (GrB_MIN_FP32 ) ;
140 if (type == GrB_FP64 ) return (GrB_MIN_FP64 ) ;
141 // no complex min
142
143 }
144 else if (MATCH (op_name, "max"))
145 {
146
147 if (type == GrB_BOOL ) return (GrB_MAX_BOOL ) ;
148 if (type == GrB_INT8 ) return (GrB_MAX_INT8 ) ;
149 if (type == GrB_INT16 ) return (GrB_MAX_INT16 ) ;
150 if (type == GrB_INT32 ) return (GrB_MAX_INT32 ) ;
151 if (type == GrB_INT64 ) return (GrB_MAX_INT64 ) ;
152 if (type == GrB_UINT8 ) return (GrB_MAX_UINT8 ) ;
153 if (type == GrB_UINT16) return (GrB_MAX_UINT16) ;
154 if (type == GrB_UINT32) return (GrB_MAX_UINT32) ;
155 if (type == GrB_UINT64) return (GrB_MAX_UINT64) ;
156 if (type == GrB_FP32 ) return (GrB_MAX_FP32 ) ;
157 if (type == GrB_FP64 ) return (GrB_MAX_FP64 ) ;
158 // no complex max
159
160 }
161 else if (MATCH (op_name, "+") || MATCH (op_name, "plus"))
162 {
163
164 if (type == GrB_BOOL ) return (GrB_PLUS_BOOL ) ;
165 if (type == GrB_INT8 ) return (GrB_PLUS_INT8 ) ;
166 if (type == GrB_INT16 ) return (GrB_PLUS_INT16 ) ;
167 if (type == GrB_INT32 ) return (GrB_PLUS_INT32 ) ;
168 if (type == GrB_INT64 ) return (GrB_PLUS_INT64 ) ;
169 if (type == GrB_UINT8 ) return (GrB_PLUS_UINT8 ) ;
170 if (type == GrB_UINT16) return (GrB_PLUS_UINT16) ;
171 if (type == GrB_UINT32) return (GrB_PLUS_UINT32) ;
172 if (type == GrB_UINT64) return (GrB_PLUS_UINT64) ;
173 if (type == GrB_FP32 ) return (GrB_PLUS_FP32 ) ;
174 if (type == GrB_FP64 ) return (GrB_PLUS_FP64 ) ;
175 if (type == GxB_FC32 ) return (GxB_PLUS_FC32 ) ;
176 if (type == GxB_FC64 ) return (GxB_PLUS_FC64 ) ;
177
178 }
179 else if (MATCH (op_name, "-") || MATCH (op_name, "minus"))
180 {
181
182 if (type == GrB_BOOL ) return (GrB_MINUS_BOOL ) ;
183 if (type == GrB_INT8 ) return (GrB_MINUS_INT8 ) ;
184 if (type == GrB_INT16 ) return (GrB_MINUS_INT16 ) ;
185 if (type == GrB_INT32 ) return (GrB_MINUS_INT32 ) ;
186 if (type == GrB_INT64 ) return (GrB_MINUS_INT64 ) ;
187 if (type == GrB_UINT8 ) return (GrB_MINUS_UINT8 ) ;
188 if (type == GrB_UINT16) return (GrB_MINUS_UINT16) ;
189 if (type == GrB_UINT32) return (GrB_MINUS_UINT32) ;
190 if (type == GrB_UINT64) return (GrB_MINUS_UINT64) ;
191 if (type == GrB_FP32 ) return (GrB_MINUS_FP32 ) ;
192 if (type == GrB_FP64 ) return (GrB_MINUS_FP64 ) ;
193 if (type == GxB_FC32 ) return (GxB_MINUS_FC32 ) ;
194 if (type == GxB_FC64 ) return (GxB_MINUS_FC64 ) ;
195
196 }
197 else if (MATCH (op_name, "rminus"))
198 {
199
200 if (type == GrB_BOOL ) return (GxB_RMINUS_BOOL ) ;
201 if (type == GrB_INT8 ) return (GxB_RMINUS_INT8 ) ;
202 if (type == GrB_INT16 ) return (GxB_RMINUS_INT16 ) ;
203 if (type == GrB_INT32 ) return (GxB_RMINUS_INT32 ) ;
204 if (type == GrB_INT64 ) return (GxB_RMINUS_INT64 ) ;
205 if (type == GrB_UINT8 ) return (GxB_RMINUS_UINT8 ) ;
206 if (type == GrB_UINT16) return (GxB_RMINUS_UINT16) ;
207 if (type == GrB_UINT32) return (GxB_RMINUS_UINT32) ;
208 if (type == GrB_UINT64) return (GxB_RMINUS_UINT64) ;
209 if (type == GrB_FP32 ) return (GxB_RMINUS_FP32 ) ;
210 if (type == GrB_FP64 ) return (GxB_RMINUS_FP64 ) ;
211 if (type == GxB_FC32 ) return (GxB_RMINUS_FC32 ) ;
212 if (type == GxB_FC64 ) return (GxB_RMINUS_FC64 ) ;
213
214 }
215 else if (MATCH (op_name, "*") || MATCH (op_name, "times"))
216 {
217
218 if (type == GrB_BOOL ) return (GrB_TIMES_BOOL ) ;
219 if (type == GrB_INT8 ) return (GrB_TIMES_INT8 ) ;
220 if (type == GrB_INT16 ) return (GrB_TIMES_INT16 ) ;
221 if (type == GrB_INT32 ) return (GrB_TIMES_INT32 ) ;
222 if (type == GrB_INT64 ) return (GrB_TIMES_INT64 ) ;
223 if (type == GrB_UINT8 ) return (GrB_TIMES_UINT8 ) ;
224 if (type == GrB_UINT16) return (GrB_TIMES_UINT16) ;
225 if (type == GrB_UINT32) return (GrB_TIMES_UINT32) ;
226 if (type == GrB_UINT64) return (GrB_TIMES_UINT64) ;
227 if (type == GrB_FP32 ) return (GrB_TIMES_FP32 ) ;
228 if (type == GrB_FP64 ) return (GrB_TIMES_FP64 ) ;
229 if (type == GxB_FC32 ) return (GxB_TIMES_FC32 ) ;
230 if (type == GxB_FC64 ) return (GxB_TIMES_FC64 ) ;
231
232 }
233 else if (MATCH (op_name, "/") || MATCH (op_name, "div"))
234 {
235
236 if (type == GrB_BOOL ) return (GrB_DIV_BOOL ) ;
237 if (type == GrB_INT8 ) return (GrB_DIV_INT8 ) ;
238 if (type == GrB_INT16 ) return (GrB_DIV_INT16 ) ;
239 if (type == GrB_INT32 ) return (GrB_DIV_INT32 ) ;
240 if (type == GrB_INT64 ) return (GrB_DIV_INT64 ) ;
241 if (type == GrB_UINT8 ) return (GrB_DIV_UINT8 ) ;
242 if (type == GrB_UINT16) return (GrB_DIV_UINT16) ;
243 if (type == GrB_UINT32) return (GrB_DIV_UINT32) ;
244 if (type == GrB_UINT64) return (GrB_DIV_UINT64) ;
245 if (type == GrB_FP32 ) return (GrB_DIV_FP32 ) ;
246 if (type == GrB_FP64 ) return (GrB_DIV_FP64 ) ;
247 if (type == GxB_FC32 ) return (GxB_DIV_FC32 ) ;
248 if (type == GxB_FC64 ) return (GxB_DIV_FC64 ) ;
249
250 }
251 else if (MATCH (op_name, "\\") || MATCH (op_name, "rdiv"))
252 {
253
254 if (type == GrB_BOOL ) return (GxB_RDIV_BOOL ) ;
255 if (type == GrB_INT8 ) return (GxB_RDIV_INT8 ) ;
256 if (type == GrB_INT16 ) return (GxB_RDIV_INT16 ) ;
257 if (type == GrB_INT32 ) return (GxB_RDIV_INT32 ) ;
258 if (type == GrB_INT64 ) return (GxB_RDIV_INT64 ) ;
259 if (type == GrB_UINT8 ) return (GxB_RDIV_UINT8 ) ;
260 if (type == GrB_UINT16) return (GxB_RDIV_UINT16) ;
261 if (type == GrB_UINT32) return (GxB_RDIV_UINT32) ;
262 if (type == GrB_UINT64) return (GxB_RDIV_UINT64) ;
263 if (type == GrB_FP32 ) return (GxB_RDIV_FP32 ) ;
264 if (type == GrB_FP64 ) return (GxB_RDIV_FP64 ) ;
265 if (type == GxB_FC32 ) return (GxB_RDIV_FC32 ) ;
266 if (type == GxB_FC64 ) return (GxB_RDIV_FC64 ) ;
267
268 }
269 else if (MATCH (op_name, "iseq"))
270 {
271
272 if (type == GrB_BOOL ) return (GxB_ISEQ_BOOL ) ;
273 if (type == GrB_INT8 ) return (GxB_ISEQ_INT8 ) ;
274 if (type == GrB_INT16 ) return (GxB_ISEQ_INT16 ) ;
275 if (type == GrB_INT32 ) return (GxB_ISEQ_INT32 ) ;
276 if (type == GrB_INT64 ) return (GxB_ISEQ_INT64 ) ;
277 if (type == GrB_UINT8 ) return (GxB_ISEQ_UINT8 ) ;
278 if (type == GrB_UINT16) return (GxB_ISEQ_UINT16) ;
279 if (type == GrB_UINT32) return (GxB_ISEQ_UINT32) ;
280 if (type == GrB_UINT64) return (GxB_ISEQ_UINT64) ;
281 if (type == GrB_FP32 ) return (GxB_ISEQ_FP32 ) ;
282 if (type == GrB_FP64 ) return (GxB_ISEQ_FP64 ) ;
283 if (type == GxB_FC32 ) return (GxB_ISEQ_FC32 ) ;
284 if (type == GxB_FC64 ) return (GxB_ISEQ_FC64 ) ;
285
286 }
287 else if (MATCH (op_name, "isne"))
288 {
289
290 if (type == GrB_BOOL ) return (GxB_ISNE_BOOL ) ;
291 if (type == GrB_INT8 ) return (GxB_ISNE_INT8 ) ;
292 if (type == GrB_INT16 ) return (GxB_ISNE_INT16 ) ;
293 if (type == GrB_INT32 ) return (GxB_ISNE_INT32 ) ;
294 if (type == GrB_INT64 ) return (GxB_ISNE_INT64 ) ;
295 if (type == GrB_UINT8 ) return (GxB_ISNE_UINT8 ) ;
296 if (type == GrB_UINT16) return (GxB_ISNE_UINT16) ;
297 if (type == GrB_UINT32) return (GxB_ISNE_UINT32) ;
298 if (type == GrB_UINT64) return (GxB_ISNE_UINT64) ;
299 if (type == GrB_FP32 ) return (GxB_ISNE_FP32 ) ;
300 if (type == GrB_FP64 ) return (GxB_ISNE_FP64 ) ;
301 if (type == GxB_FC32 ) return (GxB_ISNE_FC32 ) ;
302 if (type == GxB_FC64 ) return (GxB_ISNE_FC64 ) ;
303
304 }
305 else if (MATCH (op_name, "isgt"))
306 {
307
308 if (type == GrB_BOOL ) return (GxB_ISGT_BOOL ) ;
309 if (type == GrB_INT8 ) return (GxB_ISGT_INT8 ) ;
310 if (type == GrB_INT16 ) return (GxB_ISGT_INT16 ) ;
311 if (type == GrB_INT32 ) return (GxB_ISGT_INT32 ) ;
312 if (type == GrB_INT64 ) return (GxB_ISGT_INT64 ) ;
313 if (type == GrB_UINT8 ) return (GxB_ISGT_UINT8 ) ;
314 if (type == GrB_UINT16) return (GxB_ISGT_UINT16) ;
315 if (type == GrB_UINT32) return (GxB_ISGT_UINT32) ;
316 if (type == GrB_UINT64) return (GxB_ISGT_UINT64) ;
317 if (type == GrB_FP32 ) return (GxB_ISGT_FP32 ) ;
318 if (type == GrB_FP64 ) return (GxB_ISGT_FP64 ) ;
319
320 }
321 else if (MATCH (op_name, "islt"))
322 {
323
324 if (type == GrB_BOOL ) return (GxB_ISLT_BOOL ) ;
325 if (type == GrB_INT8 ) return (GxB_ISLT_INT8 ) ;
326 if (type == GrB_INT16 ) return (GxB_ISLT_INT16 ) ;
327 if (type == GrB_INT32 ) return (GxB_ISLT_INT32 ) ;
328 if (type == GrB_INT64 ) return (GxB_ISLT_INT64 ) ;
329 if (type == GrB_UINT8 ) return (GxB_ISLT_UINT8 ) ;
330 if (type == GrB_UINT16) return (GxB_ISLT_UINT16) ;
331 if (type == GrB_UINT32) return (GxB_ISLT_UINT32) ;
332 if (type == GrB_UINT64) return (GxB_ISLT_UINT64) ;
333 if (type == GrB_FP32 ) return (GxB_ISLT_FP32 ) ;
334 if (type == GrB_FP64 ) return (GxB_ISLT_FP64 ) ;
335
336 }
337 else if (MATCH (op_name, "isge"))
338 {
339
340 if (type == GrB_BOOL ) return (GxB_ISGE_BOOL ) ;
341 if (type == GrB_INT8 ) return (GxB_ISGE_INT8 ) ;
342 if (type == GrB_INT16 ) return (GxB_ISGE_INT16 ) ;
343 if (type == GrB_INT32 ) return (GxB_ISGE_INT32 ) ;
344 if (type == GrB_INT64 ) return (GxB_ISGE_INT64 ) ;
345 if (type == GrB_UINT8 ) return (GxB_ISGE_UINT8 ) ;
346 if (type == GrB_UINT16) return (GxB_ISGE_UINT16) ;
347 if (type == GrB_UINT32) return (GxB_ISGE_UINT32) ;
348 if (type == GrB_UINT64) return (GxB_ISGE_UINT64) ;
349 if (type == GrB_FP32 ) return (GxB_ISGE_FP32 ) ;
350 if (type == GrB_FP64 ) return (GxB_ISGE_FP64 ) ;
351
352 }
353 else if (MATCH (op_name, "isle"))
354 {
355
356 if (type == GrB_BOOL ) return (GxB_ISLE_BOOL ) ;
357 if (type == GrB_INT8 ) return (GxB_ISLE_INT8 ) ;
358 if (type == GrB_INT16 ) return (GxB_ISLE_INT16 ) ;
359 if (type == GrB_INT32 ) return (GxB_ISLE_INT32 ) ;
360 if (type == GrB_INT64 ) return (GxB_ISLE_INT64 ) ;
361 if (type == GrB_UINT8 ) return (GxB_ISLE_UINT8 ) ;
362 if (type == GrB_UINT16) return (GxB_ISLE_UINT16) ;
363 if (type == GrB_UINT32) return (GxB_ISLE_UINT32) ;
364 if (type == GrB_UINT64) return (GxB_ISLE_UINT64) ;
365 if (type == GrB_FP32 ) return (GxB_ISLE_FP32 ) ;
366 if (type == GrB_FP64 ) return (GxB_ISLE_FP64 ) ;
367
368 }
369 else if (MATCH (op_name, "==") || MATCH (op_name, "eq"))
370 {
371
372 if (type == GrB_BOOL ) return (GrB_EQ_BOOL ) ; // == GrB_LXNOR
373 if (type == GrB_INT8 ) return (GrB_EQ_INT8 ) ;
374 if (type == GrB_INT16 ) return (GrB_EQ_INT16 ) ;
375 if (type == GrB_INT32 ) return (GrB_EQ_INT32 ) ;
376 if (type == GrB_INT64 ) return (GrB_EQ_INT64 ) ;
377 if (type == GrB_UINT8 ) return (GrB_EQ_UINT8 ) ;
378 if (type == GrB_UINT16) return (GrB_EQ_UINT16) ;
379 if (type == GrB_UINT32) return (GrB_EQ_UINT32) ;
380 if (type == GrB_UINT64) return (GrB_EQ_UINT64) ;
381 if (type == GrB_FP32 ) return (GrB_EQ_FP32 ) ;
382 if (type == GrB_FP64 ) return (GrB_EQ_FP64 ) ;
383 if (type == GxB_FC32 ) return (GxB_EQ_FC32 ) ;
384 if (type == GxB_FC64 ) return (GxB_EQ_FC64 ) ;
385
386 }
387 else if (MATCH (op_name, "~=") || MATCH (op_name, "ne"))
388 {
389
390 if (type == GrB_BOOL ) return (GrB_NE_BOOL ) ;
391 if (type == GrB_INT8 ) return (GrB_NE_INT8 ) ;
392 if (type == GrB_INT16 ) return (GrB_NE_INT16 ) ;
393 if (type == GrB_INT32 ) return (GrB_NE_INT32 ) ;
394 if (type == GrB_INT64 ) return (GrB_NE_INT64 ) ;
395 if (type == GrB_UINT8 ) return (GrB_NE_UINT8 ) ;
396 if (type == GrB_UINT16) return (GrB_NE_UINT16) ;
397 if (type == GrB_UINT32) return (GrB_NE_UINT32) ;
398 if (type == GrB_UINT64) return (GrB_NE_UINT64) ;
399 if (type == GrB_FP32 ) return (GrB_NE_FP32 ) ;
400 if (type == GrB_FP64 ) return (GrB_NE_FP64 ) ;
401 if (type == GxB_FC32 ) return (GxB_NE_FC32 ) ;
402 if (type == GxB_FC64 ) return (GxB_NE_FC64 ) ;
403
404 }
405 else if (MATCH (op_name, ">") || MATCH (op_name, "gt"))
406 {
407
408 if (type == GrB_BOOL ) return (GrB_GT_BOOL ) ;
409 if (type == GrB_INT8 ) return (GrB_GT_INT8 ) ;
410 if (type == GrB_INT16 ) return (GrB_GT_INT16 ) ;
411 if (type == GrB_INT32 ) return (GrB_GT_INT32 ) ;
412 if (type == GrB_INT64 ) return (GrB_GT_INT64 ) ;
413 if (type == GrB_UINT8 ) return (GrB_GT_UINT8 ) ;
414 if (type == GrB_UINT16) return (GrB_GT_UINT16) ;
415 if (type == GrB_UINT32) return (GrB_GT_UINT32) ;
416 if (type == GrB_UINT64) return (GrB_GT_UINT64) ;
417 if (type == GrB_FP32 ) return (GrB_GT_FP32 ) ;
418 if (type == GrB_FP64 ) return (GrB_GT_FP64 ) ;
419
420 }
421 else if (MATCH (op_name, "<") || MATCH (op_name, "lt"))
422 {
423
424 if (type == GrB_BOOL ) return (GrB_LT_BOOL ) ;
425 if (type == GrB_INT8 ) return (GrB_LT_INT8 ) ;
426 if (type == GrB_INT16 ) return (GrB_LT_INT16 ) ;
427 if (type == GrB_INT32 ) return (GrB_LT_INT32 ) ;
428 if (type == GrB_INT64 ) return (GrB_LT_INT64 ) ;
429 if (type == GrB_UINT8 ) return (GrB_LT_UINT8 ) ;
430 if (type == GrB_UINT16) return (GrB_LT_UINT16) ;
431 if (type == GrB_UINT32) return (GrB_LT_UINT32) ;
432 if (type == GrB_UINT64) return (GrB_LT_UINT64) ;
433 if (type == GrB_FP32 ) return (GrB_LT_FP32 ) ;
434 if (type == GrB_FP64 ) return (GrB_LT_FP64 ) ;
435
436 }
437 else if (MATCH (op_name, ">=") || MATCH (op_name, "ge"))
438 {
439
440 if (type == GrB_BOOL ) return (GrB_GE_BOOL ) ;
441 if (type == GrB_INT8 ) return (GrB_GE_INT8 ) ;
442 if (type == GrB_INT16 ) return (GrB_GE_INT16 ) ;
443 if (type == GrB_INT32 ) return (GrB_GE_INT32 ) ;
444 if (type == GrB_INT64 ) return (GrB_GE_INT64 ) ;
445 if (type == GrB_UINT8 ) return (GrB_GE_UINT8 ) ;
446 if (type == GrB_UINT16) return (GrB_GE_UINT16) ;
447 if (type == GrB_UINT32) return (GrB_GE_UINT32) ;
448 if (type == GrB_UINT64) return (GrB_GE_UINT64) ;
449 if (type == GrB_FP32 ) return (GrB_GE_FP32 ) ;
450 if (type == GrB_FP64 ) return (GrB_GE_FP64 ) ;
451
452 }
453 else if (MATCH (op_name, "<=") || MATCH (op_name, "le"))
454 {
455
456 if (type == GrB_BOOL ) return (GrB_LE_BOOL ) ;
457 if (type == GrB_INT8 ) return (GrB_LE_INT8 ) ;
458 if (type == GrB_INT16 ) return (GrB_LE_INT16 ) ;
459 if (type == GrB_INT32 ) return (GrB_LE_INT32 ) ;
460 if (type == GrB_INT64 ) return (GrB_LE_INT64 ) ;
461 if (type == GrB_UINT8 ) return (GrB_LE_UINT8 ) ;
462 if (type == GrB_UINT16) return (GrB_LE_UINT16) ;
463 if (type == GrB_UINT32) return (GrB_LE_UINT32) ;
464 if (type == GrB_UINT64) return (GrB_LE_UINT64) ;
465 if (type == GrB_FP32 ) return (GrB_LE_FP32 ) ;
466 if (type == GrB_FP64 ) return (GrB_LE_FP64 ) ;
467
468 }
469 else if (MATCH (op_name, "||") || MATCH (op_name, "|") ||
470 MATCH (op_name, "or") || MATCH (op_name, "lor"))
471 {
472
473 if (type == GrB_BOOL ) return (GrB_LOR ) ;
474 if (type == GrB_INT8 ) return (GxB_LOR_INT8 ) ;
475 if (type == GrB_INT16 ) return (GxB_LOR_INT16 ) ;
476 if (type == GrB_INT32 ) return (GxB_LOR_INT32 ) ;
477 if (type == GrB_INT64 ) return (GxB_LOR_INT64 ) ;
478 if (type == GrB_UINT8 ) return (GxB_LOR_UINT8 ) ;
479 if (type == GrB_UINT16) return (GxB_LOR_UINT16) ;
480 if (type == GrB_UINT32) return (GxB_LOR_UINT32) ;
481 if (type == GrB_UINT64) return (GxB_LOR_UINT64) ;
482 if (type == GrB_FP32 ) return (GxB_LOR_FP32 ) ;
483 if (type == GrB_FP64 ) return (GxB_LOR_FP64 ) ;
484
485 }
486 else if (MATCH (op_name, "&&") || MATCH (op_name, "&") ||
487 MATCH (op_name, "and") || MATCH (op_name, "land"))
488 {
489
490 if (type == GrB_BOOL ) return (GrB_LAND ) ;
491 if (type == GrB_INT8 ) return (GxB_LAND_INT8 ) ;
492 if (type == GrB_INT16 ) return (GxB_LAND_INT16 ) ;
493 if (type == GrB_INT32 ) return (GxB_LAND_INT32 ) ;
494 if (type == GrB_INT64 ) return (GxB_LAND_INT64 ) ;
495 if (type == GrB_UINT8 ) return (GxB_LAND_UINT8 ) ;
496 if (type == GrB_UINT16) return (GxB_LAND_UINT16) ;
497 if (type == GrB_UINT32) return (GxB_LAND_UINT32) ;
498 if (type == GrB_UINT64) return (GxB_LAND_UINT64) ;
499 if (type == GrB_FP32 ) return (GxB_LAND_FP32 ) ;
500 if (type == GrB_FP64 ) return (GxB_LAND_FP64 ) ;
501
502 }
503 else if (MATCH (op_name, "xor") || MATCH (op_name, "lxor"))
504 {
505
506 if (type == GrB_BOOL ) return (GrB_LXOR ) ;
507 if (type == GrB_INT8 ) return (GxB_LXOR_INT8 ) ;
508 if (type == GrB_INT16 ) return (GxB_LXOR_INT16 ) ;
509 if (type == GrB_INT32 ) return (GxB_LXOR_INT32 ) ;
510 if (type == GrB_INT64 ) return (GxB_LXOR_INT64 ) ;
511 if (type == GrB_UINT8 ) return (GxB_LXOR_UINT8 ) ;
512 if (type == GrB_UINT16) return (GxB_LXOR_UINT16) ;
513 if (type == GrB_UINT32) return (GxB_LXOR_UINT32) ;
514 if (type == GrB_UINT64) return (GxB_LXOR_UINT64) ;
515 if (type == GrB_FP32 ) return (GxB_LXOR_FP32 ) ;
516 if (type == GrB_FP64 ) return (GxB_LXOR_FP64 ) ;
517
518 }
519 else if (MATCH (op_name, "lxnor") || MATCH (op_name, "xnor"))
520 {
521
522 if (type == GrB_BOOL ) return (GrB_LXNOR ) ; // == GrB_EQ_BOOL
523
524 }
525 else if (MATCH (op_name, "atan2"))
526 {
527
528 if (type == GrB_FP32 ) return (GxB_ATAN2_FP32 ) ;
529 if (type == GrB_FP64 ) return (GxB_ATAN2_FP64 ) ;
530
531 }
532 else if (MATCH (op_name, "hypot"))
533 {
534
535 if (type == GrB_FP32 ) return (GxB_HYPOT_FP32 ) ;
536 if (type == GrB_FP64 ) return (GxB_HYPOT_FP64 ) ;
537
538 }
539 else if (MATCH (op_name, "fmod"))
540 {
541
542 if (type == GrB_FP32 ) return (GxB_FMOD_FP32 ) ;
543 if (type == GrB_FP64 ) return (GxB_FMOD_FP64 ) ;
544
545 }
546 else if (MATCH (op_name, "remainder"))
547 {
548
549 if (type == GrB_FP32 ) return (GxB_REMAINDER_FP32 ) ;
550 if (type == GrB_FP64 ) return (GxB_REMAINDER_FP64 ) ;
551
552 }
553 else if (MATCH (op_name, "copysign"))
554 {
555
556 if (type == GrB_FP32 ) return (GxB_COPYSIGN_FP32 ) ;
557 if (type == GrB_FP64 ) return (GxB_COPYSIGN_FP64 ) ;
558
559 }
560 else if (MATCH (op_name, "cmplx"))
561 {
562
563 if (type == GrB_FP32 ) return (GxB_CMPLX_FP32 ) ;
564 if (type == GrB_FP64 ) return (GxB_CMPLX_FP64 ) ;
565
566 }
567 else if (MATCH (op_name, "ldexp") || MATCH (op_name, "pow2"))
568 {
569
570 if (type == GrB_FP32 ) return (GxB_LDEXP_FP32 ) ;
571 if (type == GrB_FP64 ) return (GxB_LDEXP_FP64 ) ;
572
573 }
574 else if (MATCH (op_name, "pow"))
575 {
576
577 if (type == GrB_BOOL ) return (GxB_POW_BOOL ) ;
578 if (type == GrB_INT8 ) return (GxB_POW_INT8 ) ;
579 if (type == GrB_INT16 ) return (GxB_POW_INT16 ) ;
580 if (type == GrB_INT32 ) return (GxB_POW_INT32 ) ;
581 if (type == GrB_INT64 ) return (GxB_POW_INT64 ) ;
582 if (type == GrB_UINT8 ) return (GxB_POW_UINT8 ) ;
583 if (type == GrB_UINT16) return (GxB_POW_UINT16) ;
584 if (type == GrB_UINT32) return (GxB_POW_UINT32) ;
585 if (type == GrB_UINT64) return (GxB_POW_UINT64) ;
586 if (type == GrB_FP32 ) return (GxB_POW_FP32 ) ;
587 if (type == GrB_FP64 ) return (GxB_POW_FP64 ) ;
588 if (type == GxB_FC32 ) return (GxB_POW_FC32 ) ;
589 if (type == GxB_FC64 ) return (GxB_POW_FC64 ) ;
590
591 }
592 else if (MATCH (op_name, "bitor"))
593 {
594
595 if (type == GrB_INT8 ) return (GrB_BOR_INT8 ) ;
596 if (type == GrB_INT16 ) return (GrB_BOR_INT16 ) ;
597 if (type == GrB_INT32 ) return (GrB_BOR_INT32 ) ;
598 if (type == GrB_INT64 ) return (GrB_BOR_INT64 ) ;
599 if (type == GrB_UINT8 ) return (GrB_BOR_UINT8 ) ;
600 if (type == GrB_UINT16) return (GrB_BOR_UINT16) ;
601 if (type == GrB_UINT32) return (GrB_BOR_UINT32) ;
602 if (type == GrB_UINT64) return (GrB_BOR_UINT64) ;
603
604 }
605 else if (MATCH (op_name, "bitand"))
606 {
607
608 if (type == GrB_INT8 ) return (GrB_BAND_INT8 ) ;
609 if (type == GrB_INT16 ) return (GrB_BAND_INT16 ) ;
610 if (type == GrB_INT32 ) return (GrB_BAND_INT32 ) ;
611 if (type == GrB_INT64 ) return (GrB_BAND_INT64 ) ;
612 if (type == GrB_UINT8 ) return (GrB_BAND_UINT8 ) ;
613 if (type == GrB_UINT16) return (GrB_BAND_UINT16) ;
614 if (type == GrB_UINT32) return (GrB_BAND_UINT32) ;
615 if (type == GrB_UINT64) return (GrB_BAND_UINT64) ;
616
617 }
618 else if (MATCH (op_name, "bitxor"))
619 {
620
621 if (type == GrB_INT8 ) return (GrB_BXOR_INT8 ) ;
622 if (type == GrB_INT16 ) return (GrB_BXOR_INT16 ) ;
623 if (type == GrB_INT32 ) return (GrB_BXOR_INT32 ) ;
624 if (type == GrB_INT64 ) return (GrB_BXOR_INT64 ) ;
625 if (type == GrB_UINT8 ) return (GrB_BXOR_UINT8 ) ;
626 if (type == GrB_UINT16) return (GrB_BXOR_UINT16) ;
627 if (type == GrB_UINT32) return (GrB_BXOR_UINT32) ;
628 if (type == GrB_UINT64) return (GrB_BXOR_UINT64) ;
629
630 }
631 else if (MATCH (op_name, "bitxnor"))
632 {
633
634 if (type == GrB_INT8 ) return (GrB_BXNOR_INT8 ) ;
635 if (type == GrB_INT16 ) return (GrB_BXNOR_INT16 ) ;
636 if (type == GrB_INT32 ) return (GrB_BXNOR_INT32 ) ;
637 if (type == GrB_INT64 ) return (GrB_BXNOR_INT64 ) ;
638 if (type == GrB_UINT8 ) return (GrB_BXNOR_UINT8 ) ;
639 if (type == GrB_UINT16) return (GrB_BXNOR_UINT16) ;
640 if (type == GrB_UINT32) return (GrB_BXNOR_UINT32) ;
641 if (type == GrB_UINT64) return (GrB_BXNOR_UINT64) ;
642
643 }
644 else if (MATCH (op_name, "bitget"))
645 {
646
647 if (type == GrB_INT8 ) return (GxB_BGET_INT8 ) ;
648 if (type == GrB_INT16 ) return (GxB_BGET_INT16 ) ;
649 if (type == GrB_INT32 ) return (GxB_BGET_INT32 ) ;
650 if (type == GrB_INT64 ) return (GxB_BGET_INT64 ) ;
651 if (type == GrB_UINT8 ) return (GxB_BGET_UINT8 ) ;
652 if (type == GrB_UINT16) return (GxB_BGET_UINT16) ;
653 if (type == GrB_UINT32) return (GxB_BGET_UINT32) ;
654 if (type == GrB_UINT64) return (GxB_BGET_UINT64) ;
655
656 }
657 else if (MATCH (op_name, "bitset"))
658 {
659
660 if (type == GrB_INT8 ) return (GxB_BSET_INT8 ) ;
661 if (type == GrB_INT16 ) return (GxB_BSET_INT16 ) ;
662 if (type == GrB_INT32 ) return (GxB_BSET_INT32 ) ;
663 if (type == GrB_INT64 ) return (GxB_BSET_INT64 ) ;
664 if (type == GrB_UINT8 ) return (GxB_BSET_UINT8 ) ;
665 if (type == GrB_UINT16) return (GxB_BSET_UINT16) ;
666 if (type == GrB_UINT32) return (GxB_BSET_UINT32) ;
667 if (type == GrB_UINT64) return (GxB_BSET_UINT64) ;
668
669 }
670 else if (MATCH (op_name, "bitclr"))
671 {
672
673 if (type == GrB_INT8 ) return (GxB_BCLR_INT8 ) ;
674 if (type == GrB_INT16 ) return (GxB_BCLR_INT16 ) ;
675 if (type == GrB_INT32 ) return (GxB_BCLR_INT32 ) ;
676 if (type == GrB_INT64 ) return (GxB_BCLR_INT64 ) ;
677 if (type == GrB_UINT8 ) return (GxB_BCLR_UINT8 ) ;
678 if (type == GrB_UINT16) return (GxB_BCLR_UINT16) ;
679 if (type == GrB_UINT32) return (GxB_BCLR_UINT32) ;
680 if (type == GrB_UINT64) return (GxB_BCLR_UINT64) ;
681
682 }
683 else if (MATCH (op_name, "bitshift"))
684 {
685
686 if (type == GrB_INT8 ) return (GxB_BSHIFT_INT8 ) ;
687 if (type == GrB_INT16 ) return (GxB_BSHIFT_INT16 ) ;
688 if (type == GrB_INT32 ) return (GxB_BSHIFT_INT32 ) ;
689 if (type == GrB_INT64 ) return (GxB_BSHIFT_INT64 ) ;
690 if (type == GrB_UINT8 ) return (GxB_BSHIFT_UINT8 ) ;
691 if (type == GrB_UINT16) return (GxB_BSHIFT_UINT16) ;
692 if (type == GrB_UINT32) return (GxB_BSHIFT_UINT32) ;
693 if (type == GrB_UINT64) return (GxB_BSHIFT_UINT64) ;
694
695 }
696 else if (MATCH (op_name, "firsti0" ) || MATCH (op_name, "1sti0"))
697 {
698
699 if (type == GrB_INT32) return (GxB_FIRSTI_INT32 ) ;
700 if (type == GrB_INT64
701 || type_not_given ) return (GxB_FIRSTI_INT64 ) ;
702
703 }
704 else if (MATCH (op_name, "firsti1" ) || MATCH (op_name, "1sti1") ||
705 MATCH (op_name, "firsti" ) || MATCH (op_name, "1sti"))
706 {
707
708 if (type == GrB_INT32) return (GxB_FIRSTI1_INT32 ) ;
709 if (type == GrB_INT64
710 || type_not_given ) return (GxB_FIRSTI1_INT64 ) ;
711
712 }
713 else if (MATCH (op_name, "firstj0" ) || MATCH (op_name, "1stj0"))
714 {
715
716 if (type == GrB_INT32) return (GxB_FIRSTJ_INT32 ) ;
717 if (type == GrB_INT64
718 || type_not_given ) return (GxB_FIRSTJ_INT64 ) ;
719
720 }
721 else if (MATCH (op_name, "firstj1" ) || MATCH (op_name, "1stj1") ||
722 MATCH (op_name, "firstj" ) || MATCH (op_name, "1stj"))
723 {
724
725 if (type == GrB_INT32) return (GxB_FIRSTJ1_INT32 ) ;
726 if (type == GrB_INT64
727 || type_not_given ) return (GxB_FIRSTJ1_INT64 ) ;
728
729 }
730 else if (MATCH (op_name, "secondi0") || MATCH (op_name, "2ndi0"))
731 {
732
733 if (type == GrB_INT32) return (GxB_SECONDI_INT32 ) ;
734 if (type == GrB_INT64
735 || type_not_given ) return (GxB_SECONDI_INT64 ) ;
736
737 }
738 else if (MATCH (op_name, "secondi1") || MATCH (op_name, "2ndi1") ||
739 MATCH (op_name, "secondi" ) || MATCH (op_name, "2ndi"))
740 {
741
742 if (type == GrB_INT32) return (GxB_SECONDI1_INT32 ) ;
743 if (type == GrB_INT64
744 || type_not_given ) return (GxB_SECONDI1_INT64 ) ;
745
746 }
747 else if (MATCH (op_name, "secondj0" ) || MATCH (op_name, "2ndj0"))
748 {
749
750 if (type == GrB_INT32) return (GxB_SECONDJ_INT32 ) ;
751 if (type == GrB_INT64
752 || type_not_given ) return (GxB_SECONDJ_INT64 ) ;
753
754 }
755 else if (MATCH (op_name, "secondj1") || MATCH (op_name, "2ndj1") ||
756 MATCH (op_name, "secondj" ) || MATCH (op_name, "2ndj"))
757 {
758
759 if (type == GrB_INT32) return (GxB_SECONDJ1_INT32 ) ;
760 if (type == GrB_INT64
761 || type_not_given ) return (GxB_SECONDJ1_INT64 ) ;
762
763 }
764
765 //--------------------------------------------------------------------------
766 // unknown type or operator
767 //--------------------------------------------------------------------------
768
769 // the type can be NULL for positional operators, but no others
770
771 CHECK_ERROR (type == NULL, "unknown type") ;
772 ERROR2 ("unknown binary operator", op_name) ;
773 return (NULL) ;
774 }
775
776