1 //------------------------------------------------------------------------------
2 // GB_stringify_opcode: convert unary or binary opcode to its name
3 //------------------------------------------------------------------------------
4
5 // SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2021, All Rights Reserved.
6 // SPDX-License-Identifier: Apache-2.0
7
8 //------------------------------------------------------------------------------
9
10 #include "GB.h"
11 #include "GB_stringify.h"
12
GB_stringify_opcode(GB_Opcode opcode)13 const char *GB_stringify_opcode // name of unary/binary opcode
14 (
15 GB_Opcode opcode // opcode of GraphBLAS unary or binary operator
16 )
17 {
18
19 switch (opcode)
20 {
21
22 //----------------------------------------------------------------------
23 // NOP
24 //----------------------------------------------------------------------
25
26 case GB_NOP_opcode : return ("nop") ; // no operation
27
28 //======================================================================
29 // unary operators
30 //======================================================================
31
32 //----------------------------------------------------------------------
33 // primary unary operators x=f(x)
34 //----------------------------------------------------------------------
35
36 case GB_ONE_opcode : return ("one") ; // z = 1
37 case GB_IDENTITY_opcode : return ("identity") ; // z = x
38 case GB_AINV_opcode : return ("ainv") ; // z = -x
39 case GB_ABS_opcode : return ("abs") ; // z = abs(x)
40 case GB_MINV_opcode : return ("minv") ; // z = 1/x
41 case GB_LNOT_opcode : return ("lnot") ; // z = !x
42 case GB_BNOT_opcode : return ("bnot") ; // z = ~x
43
44 //----------------------------------------------------------------------
45 // unary operators for floating-point types (real and complex)
46 //----------------------------------------------------------------------
47
48 case GB_SQRT_opcode : return ("sqrt") ; // z = sqrt (x)
49 case GB_LOG_opcode : return ("log") ; // z = log (x)
50 case GB_EXP_opcode : return ("exp") ; // z = exp (x)
51
52 case GB_SIN_opcode : return ("sin") ; // z = sin (x)
53 case GB_COS_opcode : return ("cos") ; // z = cos (x)
54 case GB_TAN_opcode : return ("tan") ; // z = tan (x)
55
56 case GB_ASIN_opcode : return ("asin") ; // z = asin (x)
57 case GB_ACOS_opcode : return ("acos") ; // z = acos (x)
58 case GB_ATAN_opcode : return ("atan") ; // z = atan (x)
59
60 case GB_SINH_opcode : return ("sinh") ; // z = sinh (x)
61 case GB_COSH_opcode : return ("cosh") ; // z = cosh (x)
62 case GB_TANH_opcode : return ("tanh") ; // z = tanh (x)
63
64 case GB_ASINH_opcode : return ("asinh") ; // z = asinh (x)
65 case GB_ACOSH_opcode : return ("acosh") ; // z = acosh (x)
66 case GB_ATANH_opcode : return ("atanh") ; // z = atanh (x)
67
68 case GB_SIGNUM_opcode : return ("signum") ; // z = signum (x)
69 case GB_CEIL_opcode : return ("ceil") ; // z = ceil (x)
70 case GB_FLOOR_opcode : return ("floor") ; // z = floor (x)
71 case GB_ROUND_opcode : return ("round") ; // z = round (x)
72 case GB_TRUNC_opcode : return ("trunc") ; // z = trunc (x)
73
74 case GB_EXP2_opcode : return ("exp2") ; // z = exp2 (x)
75 case GB_EXPM1_opcode : return ("expm1") ; // z = expm1 (x)
76 case GB_LOG10_opcode : return ("log10") ; // z = log10 (x)
77 case GB_LOG1P_opcode : return ("log1p") ; // z = log1P (x)
78 case GB_LOG2_opcode : return ("log2") ; // z = log2 (x)
79
80 //----------------------------------------------------------------------
81 // unary operators for real floating-point types
82 //----------------------------------------------------------------------
83
84 case GB_LGAMMA_opcode : return ("lgamma") ; // z = lgamma (x)
85 case GB_TGAMMA_opcode : return ("tgamma") ; // z = tgamma (x)
86 case GB_ERF_opcode : return ("erf") ; // z = erf (x)
87 case GB_ERFC_opcode : return ("erfc") ; // z = erfc (x)
88 case GB_FREXPX_opcode : return ("frexpx") ; // z = frexpx (x)
89 case GB_FREXPE_opcode : return ("frexpe") ; // z = frexpe (x)
90
91 //----------------------------------------------------------------------
92 // unary operators for complex types only
93 //----------------------------------------------------------------------
94
95 case GB_CONJ_opcode : return ("conj") ; // z = conj (x)
96
97 //----------------------------------------------------------------------
98 // unary operators where z is real and x is complex
99 //----------------------------------------------------------------------
100
101 case GB_CREAL_opcode : return ("creal") ; // z = creal (x)
102 case GB_CIMAG_opcode : return ("cimag") ; // z = cimag (x)
103 case GB_CARG_opcode : return ("carg") ; // z = carg (x)
104
105 //----------------------------------------------------------------------
106 // unary operators where z is bool and x is any floating-point type
107 //----------------------------------------------------------------------
108
109 case GB_ISINF_opcode : return ("isinf") ; // z = isinf (x)
110 case GB_ISNAN_opcode : return ("isnan") ; // z = isnan (x)
111 case GB_ISFINITE_opcode : return ("isfinite") ; // z = isfinite (x)
112
113 //----------------------------------------------------------------------
114 // positional unary operators: z is int64, x is ignored
115 //----------------------------------------------------------------------
116
117 case GB_POSITIONI_opcode : return ("positioni") ;
118 case GB_POSITIONI1_opcode : return ("positioni1") ;
119 case GB_POSITIONJ_opcode : return ("positionj") ;
120 case GB_POSITIONJ1_opcode : return ("positionj1") ;
121
122 //======================================================================
123 // binary operators
124 //======================================================================
125
126 //----------------------------------------------------------------------
127 // binary operators z=f(x,y) that return the same type as their inputs
128 //----------------------------------------------------------------------
129
130 case GB_FIRST_opcode : return ("first") ; // z = x
131 case GB_SECOND_opcode : return ("second") ; // z = y
132 case GB_ANY_opcode : return ("any") ; // z = pick x or y
133 case GB_PAIR_opcode : return ("pair") ; // z = 1
134 case GB_MIN_opcode : return ("min") ; // z = min(x,y)
135 case GB_MAX_opcode : return ("max") ; // z = max(x,y)
136 case GB_PLUS_opcode : return ("plus") ; // z = x + y
137 case GB_MINUS_opcode : return ("minus") ; // z = x - y
138 case GB_RMINUS_opcode : return ("rminus") ; // z = y - x
139 case GB_TIMES_opcode : return ("times") ; // z = x * y
140 case GB_DIV_opcode : return ("div") ; // z = x / y
141 case GB_RDIV_opcode : return ("rdiv") ; // z = y / x
142 case GB_POW_opcode : return ("pow") ; // z = pow (x,y)
143
144 case GB_ISEQ_opcode : return ("iseq") ; // z = (x == y)
145 case GB_ISNE_opcode : return ("isne") ; // z = (x != y)
146 case GB_ISGT_opcode : return ("isgt") ; // z = (x > y)
147 case GB_ISLT_opcode : return ("islt") ; // z = (x < y)
148 case GB_ISGE_opcode : return ("isge") ; // z = (x >= y)
149 case GB_ISLE_opcode : return ("isle") ; // z = (x <= y)
150
151 case GB_LOR_opcode : return ("lor") ; // z = x || y
152 case GB_LAND_opcode : return ("land") ; // z = x && y
153 case GB_LXOR_opcode : return ("lxor") ; // z = x != y
154
155 case GB_BOR_opcode : return ("bor") ; // z = (x | y), bitwise
156 case GB_BAND_opcode : return ("band") ; // z = (x & y), bitwise
157 case GB_BXOR_opcode : return ("bxor") ; // z = (x ^ y), bitwise
158 case GB_BXNOR_opcode : return ("bxnor") ; // z = ~(x ^ y), bitwise
159 case GB_BGET_opcode : return ("bget") ; // z = bitget (x,y)
160 case GB_BSET_opcode : return ("bset") ; // z = bitset (x,y)
161 case GB_BCLR_opcode : return ("bclr") ; // z = bitclr (x,y)
162 case GB_BSHIFT_opcode : return ("bshift") ; // z = bitshift (x,y)
163
164 //----------------------------------------------------------------------
165 // binary operators z=f(x,y) that return bool (TxT -> bool)
166 //----------------------------------------------------------------------
167
168 case GB_EQ_opcode : return ("eq") ; // z = (x == y)
169 case GB_NE_opcode : return ("ne") ; // z = (x != y)
170 case GB_GT_opcode : return ("gt") ; // z = (x > y)
171 case GB_LT_opcode : return ("lt") ; // z = (x < y)
172 case GB_GE_opcode : return ("ge") ; // z = (x >= y)
173 case GB_LE_opcode : return ("le") ; // z = (x <= y)
174
175 //----------------------------------------------------------------------
176 // binary operators for real floating-point types (TxT -> T)
177 //----------------------------------------------------------------------
178
179 case GB_ATAN2_opcode : return ("atan2") ; // z = atan2 (x,y)
180 case GB_HYPOT_opcode : return ("hypot") ; // z = hypot (x,y)
181 case GB_FMOD_opcode : return ("fmod") ; // z = fmod (x,y)
182 case GB_REMAINDER_opcode : return ("remainder") ; // z=remainder(x,y)
183 case GB_COPYSIGN_opcode : return ("copysign") ; // z=copysign (x,y)
184 case GB_LDEXP_opcode : return ("ldexp") ; // z = ldexp (x,y)
185
186 //----------------------------------------------------------------------
187 // binary operator z=f(x,y) where z is complex, x,y real:
188 //----------------------------------------------------------------------
189
190 case GB_CMPLX_opcode : return ("cmplx") ; // z = cmplx (x,y)
191
192 //----------------------------------------------------------------------
193 // positional binary operators: z is int64, x and y are ignored
194 //----------------------------------------------------------------------
195
196 case GB_FIRSTI_opcode : return ("firsti") ;
197 case GB_FIRSTI1_opcode : return ("firsti1") ;
198 case GB_FIRSTJ_opcode : return ("firstj") ;
199 case GB_FIRSTJ1_opcode : return ("firstj1") ;
200
201 case GB_SECONDI_opcode : return ("secondi") ;
202 case GB_SECONDI1_opcode : return ("secondi1") ;
203 case GB_SECONDJ_opcode : return ("secondj") ;
204 case GB_SECONDJ1_opcode : return ("secondj1") ;
205
206 //======================================================================
207 // user-defined: unary and binary operators
208 //======================================================================
209
210 case GB_USER_opcode : return ("user") ; // unary or binary
211
212 //======================================================================
213 // invalid opcode
214 //======================================================================
215
216 default : break ;
217 }
218
219 return ("") ;
220 }
221
222