1 //------------------------------------------------------------------------------
2 // GB_mex_about: print the 'about' information
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 // Test lots of random stuff. The function otherwise serves no purpose.
11
12 #include "GB_mex.h"
13 #include "GB_mex_errors.h"
14 #include "GB_bitmap_AxB_saxpy.h"
15
16 #define USAGE "GB_mex_about"
17
18 GrB_Info ack (int64_t *stuff, GrB_Matrix GunkIt) ;
19
ack(int64_t * stuff,GrB_Matrix GunkIt)20 GrB_Info ack (int64_t *stuff, GrB_Matrix GunkIt)
21 {
22 GB_RETURN_IF_NULL (stuff) ;
23 GB_RETURN_IF_NULL_OR_FAULTY (GunkIt) ;
24 return (GrB_SUCCESS) ;
25 }
26
27 bool select_plus_one (GrB_Index i, GrB_Index j,
28 const double *x, const double *thunk) ;
29
30 bool select_nothing (GrB_Index i, GrB_Index j,
31 const void *x, const void *thunk) ;
32
select_plus_one(GrB_Index i,GrB_Index j,const double * x,const double * thunk)33 bool select_plus_one (GrB_Index i, GrB_Index j,
34 const double *x, const double *thunk)
35 {
36 // return true if x >= thunk+1
37 return ((*x) >= ((*thunk)+1)) ;
38 }
39
select_nothing(GrB_Index i,GrB_Index j,const void * x,const void * thunk)40 bool select_nothing (GrB_Index i, GrB_Index j,
41 const void *x, const void *thunk)
42 {
43 return (false) ;
44 }
45
46 typedef int16_t user_int ;
47
mexFunction(int nargout,mxArray * pargout[],int nargin,const mxArray * pargin[])48 void mexFunction
49 (
50 int nargout,
51 mxArray *pargout [ ],
52 int nargin,
53 const mxArray *pargin [ ]
54 )
55 {
56
57 //--------------------------------------------------------------------------
58 // start error log
59 //--------------------------------------------------------------------------
60
61 FILE *f = fopen ("errlog2.txt", "w") ;
62 printf ("in %s\n", __FILE__) ;
63 char *err ;
64
65 //--------------------------------------------------------------------------
66 // test GrB_init with invalid mode
67 //--------------------------------------------------------------------------
68
69 GB_Global_GrB_init_called_set (false) ;
70 GrB_Info info = GrB_init (911) ;
71 printf ("expected error: [%d]\n", info) ;
72 mxAssert (info == GrB_INVALID_VALUE, "error must be 'invalid value'") ;
73
74 bool malloc_debug = GB_mx_get_global (true) ;
75
76 // GB_CONTEXT (USAGE) ;
77
78 printf ("in %s:\n", __FILE__) ;
79
80 printf ("sizeof (struct GB_Type_opaque) %d\n",
81 sizeof (struct GB_Type_opaque)) ;
82 printf ("sizeof (struct GB_UnaryOp_opaque) %d\n",
83 sizeof (struct GB_UnaryOp_opaque)) ;
84 printf ("sizeof (struct GB_BinaryOp_opaque) %d\n",
85 sizeof (struct GB_BinaryOp_opaque)) ;
86 printf ("sizeof (struct GB_SelectOp_opaque) %d\n",
87 sizeof (struct GB_SelectOp_opaque)) ;
88 printf ("sizeof (struct GB_Monoid_opaque) %d\n",
89 sizeof (struct GB_Monoid_opaque)) ;
90 printf ("sizeof (struct GB_Semiring_opaque) %d\n",
91 sizeof (struct GB_Semiring_opaque)) ;
92 printf ("sizeof (struct GB_Vector_opaque) %d\n",
93 sizeof (struct GB_Vector_opaque)) ;
94 printf ("sizeof (struct GB_Matrix_opaque) %d\n",
95 sizeof (struct GB_Matrix_opaque)) ;
96 printf ("sizeof (struct GB_Descriptor_opaque) %d\n",
97 sizeof (struct GB_Descriptor_opaque)) ;
98
99 size_t s ;
100 GxB_Type_size (&s, GrB_BOOL ) ; printf ("%d %d\n", s, sizeof (bool ));
101 GxB_Type_size (&s, GrB_INT8 ) ; printf ("%d %d\n", s, sizeof (int8_t ));
102 GxB_Type_size (&s, GrB_UINT8 ) ; printf ("%d %d\n", s, sizeof (uint8_t ));
103 GxB_Type_size (&s, GrB_INT16 ) ; printf ("%d %d\n", s, sizeof (int16_t ));
104 GxB_Type_size (&s, GrB_UINT16) ; printf ("%d %d\n", s, sizeof (uint16_t ));
105 GxB_Type_size (&s, GrB_INT32 ) ; printf ("%d %d\n", s, sizeof (int32_t ));
106 GxB_Type_size (&s, GrB_UINT32) ; printf ("%d %d\n", s, sizeof (uint32_t ));
107 GxB_Type_size (&s, GrB_INT64 ) ; printf ("%d %d\n", s, sizeof (int64_t ));
108 GxB_Type_size (&s, GrB_UINT64) ; printf ("%d %d\n", s, sizeof (uint64_t ));
109 GxB_Type_size (&s, GrB_FP32 ) ; printf ("%d %d\n", s, sizeof (float ));
110 GxB_Type_size (&s, GrB_FP64 ) ; printf ("%d %d\n", s, sizeof (double ));
111
112 printf ("info is %d\n", info) ;
113
114 GrB_Type t ;
115
116 GB_UnaryOp_check (GrB_LNOT, "LNOT", GxB_COMPLETE, stdout) ;
117 GxB_UnaryOp_ztype (&t, GrB_LNOT) ;
118 GB_UnaryOp_check (t, "ztype", GxB_COMPLETE, stdout) ;
119 GxB_UnaryOp_xtype (&t, GrB_LNOT) ;
120 GB_UnaryOp_check (t, "xtype", GxB_COMPLETE, stdout) ;
121
122 GB_UnaryOp_check (GxB_LNOT_FP32, "LNOT_FP32", GxB_COMPLETE, stdout) ;
123 GxB_UnaryOp_ztype (&t, GxB_LNOT_FP32) ;
124 GB_UnaryOp_check (t, "ztype", GxB_COMPLETE, stdout) ;
125 GxB_UnaryOp_xtype (&t, GxB_LNOT_FP32) ;
126 GB_UnaryOp_check (t, "xtype", GxB_COMPLETE, stdout) ;
127
128 GB_BinaryOp_check (GxB_ISEQ_INT32, "ISEQ_INT32", GxB_COMPLETE, stdout) ;
129 GxB_BinaryOp_ztype (&t, GxB_ISEQ_INT32) ;
130 GB_BinaryOp_check (t, "ztype", GxB_COMPLETE, stdout) ;
131 GxB_BinaryOp_xtype (&t, GxB_ISEQ_INT32) ;
132 GB_BinaryOp_check (t, "xtype", GxB_COMPLETE, stdout) ;
133 GxB_BinaryOp_ytype (&t, GxB_ISEQ_INT32) ;
134 GB_BinaryOp_check (t, "ytype", GxB_COMPLETE, stdout) ;
135
136 GB_BinaryOp_check (GrB_EQ_INT32, "EQ_INT32", GxB_COMPLETE, stdout) ;
137 GxB_BinaryOp_ztype (&t, GrB_EQ_INT32) ;
138 GB_BinaryOp_check (t, "ztype", GxB_COMPLETE, stdout) ;
139 GxB_BinaryOp_xtype (&t, GrB_EQ_INT32) ;
140 GB_BinaryOp_check (t, "xtype", GxB_COMPLETE, stdout) ;
141 GxB_BinaryOp_ytype (&t, GrB_EQ_INT32) ;
142 GB_BinaryOp_check (t, "ytype", GxB_COMPLETE, stdout) ;
143
144 GrB_Monoid m ;
145 GrB_BinaryOp op ;
146
147 GrB_Monoid_new_UINT16_(&m, GrB_PLUS_UINT16, (uint16_t) 0) ;
148 OK (GrB_Monoid_wait_(&m)) ;
149 GB_Monoid_check (m, "plus uint16 monoid", GxB_COMPLETE, stdout) ;
150 uint16_t id ;
151 GxB_Monoid_identity (&id, m) ;
152 printf ("id is %d\n", id) ;
153 GxB_Monoid_operator (&op, m) ;
154 GB_Monoid_check (op, "plus op from monoid", GxB_COMPLETE, stdout) ;
155
156 GrB_Monoid_free_(&m) ;
157
158 int16_t id0 = INT16_MIN ;
159
160 GrB_Monoid_new_INT16_(&m, GrB_MAX_INT16, id0) ;
161 GB_Monoid_check (m, "max int16 monoid", GxB_COMPLETE, stdout) ;
162 int16_t id1 ;
163 GxB_Monoid_identity (&id1, m) ;
164 printf ("id1 is %d\n", id1) ;
165 GxB_Monoid_operator (&op, m) ;
166 GB_BinaryOp_check (op, "plus op from monoid", GxB_COMPLETE, stdout) ;
167
168 GrB_Semiring sem ;
169 GrB_Semiring_new (&sem, m, GrB_TIMES_INT16) ;
170 OK (GrB_Semiring_wait_(&sem)) ;
171 GB_Semiring_check (sem, "\nnew sem", GxB_COMPLETE, stdout) ;
172
173 GrB_Monoid mm ;
174 GxB_Semiring_add (&mm, sem) ;
175 GB_Monoid_check (mm, "sem mm", GxB_COMPLETE, stdout) ;
176 GxB_Semiring_multiply (&op, sem) ;
177 GB_BinaryOp_check (op, "sem mult", GxB_COMPLETE, stdout) ;
178
179 GrB_Monoid_free_(&m) ;
180 GrB_Semiring_free_(&sem) ;
181
182 int64_t *stuff = NULL ;
183 int64_t morestuff = 44 ;
184 GrB_Matrix Gunk ;
185 GrB_Matrix_new (&Gunk, GrB_FP64, 5, 5) ;
186 info = ack (&morestuff, Gunk) ;
187
188 GxB_Matrix_type (&t, Gunk) ;
189 GB_Type_check (t, "matrix Gunk type is:", GxB_COMPLETE, stdout) ;
190
191 GrB_Vector victor ;
192 GrB_Vector_new (&victor, GrB_UINT32, 43) ;
193 GxB_Vector_type (&t, victor) ;
194 OK (GrB_Vector_wait_(&victor)) ;
195 GB_Type_check (t, "victor type is:", GxB_COMPLETE, stdout) ;
196 GxB_Type_size (&s, t) ;
197 printf ("and its size of type is %d\n", s) ;
198 GrB_Vector_free_(&victor) ;
199
200 //--------------------------------------------------------------------------
201 // descriptor
202 //--------------------------------------------------------------------------
203
204 GrB_Descriptor Duh ;
205 GrB_Desc_Value val ;
206
207 GrB_Descriptor_new (&Duh) ;
208 GB_Descriptor_check (Duh, "\n---------------------------------- Duh:",
209 GxB_COMPLETE, stdout) ;
210 GxB_Desc_get (Duh, GrB_OUTP, &val) ; printf ("got outp %d\n", val) ; CHECK (val == GxB_DEFAULT) ;
211 GxB_Desc_get (Duh, GrB_MASK, &val) ; printf ("got mask %d\n", val) ; CHECK (val == GxB_DEFAULT) ;
212 GxB_Desc_get (Duh, GrB_INP0, &val) ; printf ("got inp0 %d\n", val) ; CHECK (val == GxB_DEFAULT) ;
213 GxB_Desc_get (Duh, GrB_INP1, &val) ; printf ("got inp1 %d\n", val) ; CHECK (val == GxB_DEFAULT) ;
214
215 GxB_Desc_set (Duh, GrB_INP0, GrB_TRAN) ;
216 GB_Descriptor_check (Duh, "\n------------------------------- Duh set:",
217 GxB_COMPLETE, stdout) ;
218 GxB_Desc_get (Duh, GrB_OUTP, &val) ; printf ("got outp %d\n", val) ; CHECK (val == GxB_DEFAULT) ;
219 GxB_Desc_get (Duh, GrB_MASK, &val) ; printf ("got mask %d\n", val) ; CHECK (val == GxB_DEFAULT) ;
220 GxB_Desc_get (Duh, GrB_INP0, &val) ; printf ("got inp0 %d\n", val) ; CHECK (val == GrB_TRAN) ;
221 GxB_Desc_get (Duh, GrB_INP1, &val) ; printf ("got inp1 %d\n", val) ; CHECK (val == GxB_DEFAULT) ;
222
223 GxB_Desc_set (Duh, GrB_MASK, GrB_COMP) ;
224 GB_Descriptor_check (Duh, "\n-----Duh set mask",
225 GxB_COMPLETE, stdout) ;
226 GxB_Desc_get (Duh, GrB_OUTP, &val) ; printf ("got outp %d\n", val) ; CHECK (val == GxB_DEFAULT) ;
227 GxB_Desc_get (Duh, GrB_MASK, &val) ; printf ("got mask %d\n", val) ; CHECK (val == GrB_COMP) ;
228 GxB_Desc_get (Duh, GrB_INP0, &val) ; printf ("got inp0 %d\n", val) ; CHECK (val == GrB_TRAN) ;
229 GxB_Desc_get (Duh, GrB_INP1, &val) ; printf ("got inp1 %d\n", val) ; CHECK (val == GxB_DEFAULT) ;
230
231 GxB_Desc_set (Duh, GrB_OUTP, GrB_REPLACE) ;
232 GB_Descriptor_check (Duh, "\n-----Duh set out",
233 GxB_COMPLETE, stdout) ;
234 GxB_Desc_get (Duh, GrB_OUTP, &val) ; printf ("got outp %d\n", val) ; CHECK (val == GrB_REPLACE) ;
235 GxB_Desc_get (Duh, GrB_MASK, &val) ; printf ("got mask %d\n", val) ; CHECK (val == GrB_COMP) ;
236 GxB_Desc_get (Duh, GrB_INP0, &val) ; printf ("got inp0 %d\n", val) ; CHECK (val == GrB_TRAN) ;
237 GxB_Desc_get (Duh, GrB_INP1, &val) ; printf ("got inp1 %d\n", val) ; CHECK (val == GxB_DEFAULT) ;
238
239 GrB_Descriptor_set (Duh, GrB_MASK, GrB_STRUCTURE) ;
240 GB_Descriptor_check (Duh, "\n-----Duh set mask structural",
241 GxB_COMPLETE, stdout) ;
242 GxB_Desc_get (Duh, GrB_OUTP, &val) ; printf ("got outp %d\n", val) ; CHECK (val == GrB_REPLACE) ;
243 GxB_Desc_get (Duh, GrB_MASK, &val) ; printf ("got mask %d\n", val) ; CHECK (val == GrB_COMP + GrB_STRUCTURE) ;
244 GxB_Desc_get (Duh, GrB_INP0, &val) ; printf ("got inp0 %d\n", val) ; CHECK (val == GrB_TRAN) ;
245 GxB_Desc_get (Duh, GrB_INP1, &val) ; printf ("got inp1 %d\n", val) ; CHECK (val == GxB_DEFAULT) ;
246
247 GrB_Descriptor_set (Duh, GrB_MASK, GxB_DEFAULT) ;
248 GB_Descriptor_check (Duh, "\n-----Duh set mask back",
249 GxB_COMPLETE, stdout) ;
250 GxB_Desc_get (Duh, GrB_OUTP, &val) ; printf ("got outp %d\n", val) ; CHECK (val == GrB_REPLACE) ;
251 GxB_Desc_get (Duh, GrB_MASK, &val) ; printf ("got mask %d\n", val) ; CHECK (val == GxB_DEFAULT) ;
252 GxB_Desc_get (Duh, GrB_INP0, &val) ; printf ("got inp0 %d\n", val) ; CHECK (val == GrB_TRAN) ;
253 GxB_Desc_get (Duh, GrB_INP1, &val) ; printf ("got inp1 %d\n", val) ; CHECK (val == GxB_DEFAULT) ;
254
255 info = GxB_Desc_set (Duh, GrB_INP1, GrB_REPLACE) ;
256 OK (GrB_Descriptor_wait_(&Duh)) ;
257 GrB_Descriptor_error_(&err, Duh) ;
258 printf ("%s\n", err) ;
259 GB_Descriptor_check (Duh, "\n-----Duh set in1",
260 GxB_COMPLETE, stdout) ;
261 GxB_Desc_get (Duh, GrB_OUTP, &val) ; printf ("got outp %d\n", val) ; CHECK (val == GrB_REPLACE) ;
262 GxB_Desc_get (Duh, GrB_MASK, &val) ; printf ("got mask %d\n", val) ; CHECK (val == GxB_DEFAULT) ;
263 GxB_Desc_get (Duh, GrB_INP0, &val) ; printf ("got inp0 %d\n", val) ; CHECK (val == GrB_TRAN) ;
264 GxB_Desc_get (Duh, GrB_INP1, &val) ; printf ("got inp1 %d\n", val) ; CHECK (val == GxB_DEFAULT) ;
265
266 GrB_Descriptor_free_(&Duh) ;
267
268 //--------------------------------------------------------------------------
269 // error handling
270 //--------------------------------------------------------------------------
271
272 info = ack (NULL, Gunk) ;
273
274 Gunk->magic = 999 ;
275 info = ack (&morestuff, Gunk) ;
276
277 Gunk->magic = GB_MAGIC ;
278 GrB_Matrix_free_(&Gunk) ;
279
280 GB_Type_check (Complex, "user Complex type", GxB_COMPLETE, stdout);
281 GxB_Type_size (&s, Complex) ;
282 printf ("size is %d\n", (int) s) ;
283
284 //--------------------------------------------------------------------------
285 // about the spec
286 //--------------------------------------------------------------------------
287
288 int all_version [3] = { -1, -1, -1 } ;
289 unsigned int version = 0 , subversion = 9999 ;
290 char *name, *date, *about, *license, *compile_date, *compile_time, *url ;
291
292 OK (GrB_getVersion (&version, &subversion)) ;
293 printf ("Spec: %d.%d.%d ("GBu"): %d.%d\n",
294 GxB_SPEC_MAJOR, GxB_SPEC_MINOR, GxB_SPEC_SUB, GxB_SPEC_VERSION,
295 version, subversion) ;
296 CHECK (version == GxB_SPEC_MAJOR) ;
297 CHECK (subversion == GxB_SPEC_MINOR) ;
298 CHECK (version == GRB_VERSION) ;
299 CHECK (subversion == GRB_SUBVERSION) ;
300 printf ("Spec Date: %s\n", GxB_SPEC_DATE) ;
301
302 OK (GxB_Global_Option_get_(GxB_API_ABOUT, &about)) ;
303 CHECK (strcmp (about, GxB_SPEC_ABOUT) == 0) ;
304 printf ("About the spec:\n%s\n", about) ;
305
306 OK (GxB_Global_Option_get_(GxB_API_DATE, &date)) ;
307 CHECK (strcmp (date, GxB_SPEC_DATE) == 0) ;
308 printf ("date: %s\n", date) ;
309
310 OK (GxB_Global_Option_get_(GxB_API_URL, &url)) ;
311 printf ("URL: %s\n", url) ;
312
313 OK (GxB_Global_Option_get_(GxB_API_VERSION, all_version)) ;
314 CHECK (all_version [0] == GxB_SPEC_MAJOR) ;
315 CHECK (all_version [1] == GxB_SPEC_MINOR) ;
316 CHECK (all_version [2] == GxB_SPEC_SUB) ;
317 printf ("Spec Version (%d.%d.%d)\n",
318 all_version [0], all_version [1], all_version [2]) ;
319
320 //--------------------------------------------------------------------------
321 // about the library
322 //--------------------------------------------------------------------------
323
324 #ifdef GxB_SUITESPARSE_GRAPHBLAS
325 printf ("library info:\n") ;
326
327 OK (GxB_Global_Option_get_(GxB_LIBRARY_NAME, &name)) ;
328 CHECK (strcmp (name, GxB_IMPLEMENTATION_NAME) == 0) ;
329 printf ("name: %s\n", name) ;
330
331 OK (GxB_Global_Option_get_(GxB_LIBRARY_DATE, &date)) ;
332 if (date != NULL) printf ("date: %s\n", date) ;
333 CHECK (strcmp (date, GxB_IMPLEMENTATION_DATE) == 0) ;
334
335 OK (GxB_Global_Option_get_(GxB_LIBRARY_ABOUT, &about)) ;
336 CHECK (strcmp (about, GxB_IMPLEMENTATION_ABOUT) == 0) ;
337 printf ("about:\n%s\n", about) ;
338
339 OK (GxB_Global_Option_get_(GxB_LIBRARY_LICENSE, &license)) ;
340 CHECK (strcmp (license, GxB_IMPLEMENTATION_LICENSE) == 0) ;
341 printf ("license:\n%s\n", license) ;
342
343 OK (GxB_Global_Option_get_(GxB_LIBRARY_VERSION, all_version)) ;
344 CHECK (all_version [0] == GxB_IMPLEMENTATION_MAJOR) ;
345 CHECK (all_version [1] == GxB_IMPLEMENTATION_MINOR) ;
346 CHECK (all_version [2] == GxB_IMPLEMENTATION_SUB) ;
347 printf ("Version (%d.%d.%d)\n",
348 all_version [0], all_version [1], all_version [2]) ;
349 printf ("Implementation: ("GBu")\n", GxB_IMPLEMENTATION) ;
350
351 OK (GxB_Global_Option_get_(GxB_LIBRARY_COMPILE_DATE, &compile_date)) ;
352 printf ("compile date: %s\n", compile_date) ;
353
354 OK (GxB_Global_Option_get_(GxB_LIBRARY_COMPILE_TIME, &compile_time)) ;
355 printf ("compile time: %s\n", compile_time) ;
356
357 OK (GxB_Global_Option_get_(GxB_LIBRARY_URL, &url)) ;
358 printf ("URL: %s\n", url) ;
359
360 #if GxB_SPEC_VERSION >= GxB_VERSION(1,0,0)
361 printf ("The spec is >= version 1.0.0\n") ;
362 #else
363 printf ("The spec is < version 1.0.0\n") ;
364 #endif
365
366 #if GxB_SPEC_VERSION < GxB_VERSION(2,3,0)
367 printf ("The spec is < version 2.3.0\n") ;
368 #else
369 printf ("The spec is >= version 2.3.0\n") ;
370 #endif
371
372 #if GxB_IMPLEMENTATION < GxB_VERSION(1,0,0)
373 printf ("This implementation is < version 1.0.0\n") ;
374 #else
375 printf ("This implementation is >= version 1.0.0\n") ;
376 #endif
377
378 #endif
379
380 //--------------------------------------------------------------------------
381 // CUDA
382 //--------------------------------------------------------------------------
383
384 int gpu_count = GB_Global_gpu_count_get ( ) ;
385 printf ("gpu count: %d\n", gpu_count) ;
386
387 GrB_Desc_Value gpu_control = -99 ;
388 OK (GxB_Global_Option_get_(GxB_GLOBAL_GPU_CONTROL, &gpu_control)) ;
389 printf ("gpu control: %d\n", gpu_control) ;
390
391 OK (GxB_Global_Option_set_(GxB_GLOBAL_GPU_CONTROL, GxB_GPU_NEVER)) ;
392 OK (GxB_Global_Option_get_(GxB_GLOBAL_GPU_CONTROL, &gpu_control)) ;
393 CHECK (gpu_control == GxB_GPU_NEVER) ;
394
395 OK (GxB_Global_Option_set_(GxB_GLOBAL_GPU_CONTROL, GxB_GPU_ALWAYS)) ;
396 OK (GxB_Global_Option_get_(GxB_GLOBAL_GPU_CONTROL, &gpu_control)) ;
397 CHECK (gpu_control == (gpu_count > 0) ? GxB_GPU_ALWAYS : GxB_GPU_NEVER) ;
398
399 OK (GxB_Global_Option_set_(GxB_GLOBAL_GPU_CONTROL, GxB_DEFAULT)) ;
400 OK (GxB_Global_Option_get_(GxB_GLOBAL_GPU_CONTROL, &gpu_control)) ;
401 CHECK (gpu_control == (gpu_count > 0) ? GxB_DEFAULT : GxB_GPU_NEVER) ;
402
403 double gpu_chunk = -1 ;
404 OK (GxB_Global_Option_get_(GxB_GLOBAL_GPU_CHUNK, &gpu_chunk)) ;
405 printf ("gpu chunk: %g\n", gpu_chunk) ;
406
407 double gpu_chunk_42 = 42e6 ;
408 OK (GxB_Global_Option_set_(GxB_GLOBAL_GPU_CHUNK, gpu_chunk_42)) ;
409 OK (GxB_Global_Option_get_(GxB_GLOBAL_GPU_CHUNK, &gpu_chunk)) ;
410 CHECK (gpu_chunk == 42e6) ;
411
412 //--------------------------------------------------------------------------
413 // types
414 //--------------------------------------------------------------------------
415
416 printf ("built-in types:\n") ;
417 GB_Type_check (GrB_BOOL, "bool", GxB_COMPLETE, stdout) ;
418 GB_Type_check (GrB_INT8, "int8", GxB_COMPLETE, stdout) ;
419 GB_Type_check (GrB_UINT8, "uint8", GxB_COMPLETE, stdout) ;
420 GB_Type_check (GrB_INT16, "int16", GxB_COMPLETE, stdout) ;
421 GB_Type_check (GrB_UINT16, "uint16", GxB_COMPLETE, stdout) ;
422 GB_Type_check (GrB_INT32, "int32", GxB_COMPLETE, stdout) ;
423 GB_Type_check (GrB_UINT32, "uint32", GxB_COMPLETE, stdout) ;
424 GB_Type_check (GrB_INT64, "int64", GxB_COMPLETE, stdout) ;
425 GB_Type_check (GrB_UINT64, "uint64", GxB_COMPLETE, stdout) ;
426 GB_Type_check (GrB_FP32, "fp32", GxB_COMPLETE, stdout) ;
427 GB_Type_check (GrB_FP64, "fp64", GxB_COMPLETE, stdout) ;
428
429 printf ("\nprinting built-in types:\n") ;
430 bool b = true ;
431 int8_t i8 = 22 ;
432 uint8_t u8 = 44 ;
433 int16_t i16 = 909 ;
434 uint16_t u16 = 777 ;
435 int32_t i32 = 3203 ;
436 uint32_t u32 = 8080 ;
437 int64_t i64 = -987 ;
438 uint64_t u64 = 987 ;
439 float f32 = 3.14 ;
440 double f64 = 99.4 ;
441
442 GB_code_check (GB_BOOL_code, &b , 5, stdout) ; printf ("\n");
443 GB_code_check (GB_INT8_code, &i8 , 5, stdout) ; printf ("\n");
444 GB_code_check (GB_UINT8_code, &u8 , 5, stdout) ; printf ("\n");
445 GB_code_check (GB_INT16_code, &i16, 5, stdout) ; printf ("\n");
446 GB_code_check (GB_UINT16_code, &u16, 5, stdout) ; printf ("\n");
447 GB_code_check (GB_INT32_code, &i32, 5, stdout) ; printf ("\n");
448 GB_code_check (GB_UINT32_code, &u32, 5, stdout) ; printf ("\n");
449 GB_code_check (GB_INT64_code, &i64, 5, stdout) ; printf ("\n");
450 GB_code_check (GB_UINT64_code, &u64, 5, stdout) ; printf ("\n");
451 GB_code_check (GB_FP32_code, &f32, 5, stdout) ; printf ("\n");
452 GB_code_check (GB_FP64_code, &f64, 5, stdout) ; printf ("\n");
453 GB_code_check (GB_UDT_code, &f64, 5, stdout) ; printf ("\n");
454
455 for (int i = 0 ; i <= GrB_PANIC + 1 ; i++)
456 {
457 printf ("info: %2d %s\n", i, GB_status_code (i)) ;
458 }
459
460 //--------------------------------------------------------------------------
461 // global get/set
462 //--------------------------------------------------------------------------
463
464 double h, bswitch [GxB_NBITMAP_SWITCH] ;
465 GxB_Format_Value ff ;
466 GxB_Global_Option_get_(GxB_HYPER_SWITCH, &h) ;
467 GxB_Global_Option_get_(GxB_BITMAP_SWITCH, bswitch) ;
468 GxB_Global_Option_get_(GxB_FORMAT, &ff) ;
469 printf ("hyper_switch %g csc %d\n", h, (ff == GxB_BY_COL)) ;
470 for (int k = 0 ; k < GxB_NBITMAP_SWITCH ; k++)
471 {
472 printf ("bitmap_switch [%d]: %g\n", k, bswitch [k]) ;
473 }
474
475 GrB_Mode mode ;
476 GxB_Global_Option_get_(GxB_MODE, &mode) ;
477 printf ("mode: %d\n", mode) ;
478
479 int nthreads ;
480 GxB_Global_Option_get_(GxB_NTHREADS, &nthreads) ;
481 printf ("# threads: %d\n", nthreads) ;
482
483 double chunk ;
484 GxB_Global_Option_get_(GxB_CHUNK, &chunk) ;
485 printf ("chunk: %g\n", chunk) ;
486
487 //--------------------------------------------------------------------------
488 // check A and B aliased
489 //--------------------------------------------------------------------------
490
491 GrB_Matrix A = NULL, B = NULL, C = NULL ;
492 OK (GrB_Matrix_new (&A, GrB_BOOL, 10000, 10000)) ;
493 OK (GrB_Matrix_new (&B, GrB_BOOL, 10000, 10000)) ;
494 OK (GrB_Matrix_setElement_BOOL (A, true, 0, 0)) ;
495 OK (GrB_Matrix_setElement_BOOL (B, true, 0, 0)) ;
496 OK (GrB_Matrix_wait_(&A)) ;
497 OK (GrB_Matrix_wait_(&B)) ;
498 CHECK (!GB_aliased (A, B)) ;
499 int64_t *Bh_save = B->h ;
500 B->h = A->h ; B->h_shallow = true ;
501 CHECK (GB_aliased (A, B)) ;
502 B->h = Bh_save ; B->h_shallow = false ;
503 CHECK (!GB_aliased (A, B)) ;
504 OK (GxB_Matrix_fprint_(A, 3, NULL)) ;
505 OK (GxB_Matrix_fprint_(B, 3, NULL)) ;
506 GrB_Matrix_free_(&A) ;
507 GrB_Matrix_free_(&B) ;
508
509 //--------------------------------------------------------------------------
510 // check descripter set/get for nthreads and chunk
511 //--------------------------------------------------------------------------
512
513 GrB_Descriptor desc ;
514 OK (GrB_Descriptor_new (&desc)) ;
515 OK (GxB_Desc_set (desc, GxB_NTHREADS, 42)) ;
516 OK (GxB_Desc_set (desc, GxB_CHUNK, (double) 12345)) ;
517 OK (GxB_Desc_get (desc, GxB_CHUNK, &chunk)) ;
518 OK (GxB_Desc_get (desc, GxB_NTHREADS, &nthreads)) ;
519 OK (GrB_Descriptor_wait_(&desc)) ;
520 OK (GxB_Descriptor_fprint_(desc, GxB_COMPLETE, NULL)) ;
521 CHECK (chunk == 12345) ;
522 CHECK (nthreads == 42) ;
523 GrB_Descriptor_free_(&desc) ;
524
525 //--------------------------------------------------------------------------
526 // make a shallow copy of an empty matrix
527 //--------------------------------------------------------------------------
528
529 OK (GrB_Matrix_new (&A, GrB_BOOL, 10000, 10000)) ;
530 struct GB_Matrix_opaque Q_header ;
531 GrB_Matrix Q = GB_clear_static_header (&Q_header) ;
532 OK (GB_shallow_copy (Q, A->is_csc, A, NULL)) ;
533 OK (GxB_Matrix_fprint_(Q, GxB_COMPLETE, NULL)) ;
534 GrB_Matrix_free_(&A) ;
535 GrB_Matrix_free_(&Q) ;
536
537 //--------------------------------------------------------------------------
538 // tests with memory tracking off
539 //--------------------------------------------------------------------------
540
541 size_t nbytes ;
542 GB_Global_malloc_tracking_set (false) ;
543 GB_void *p = GB_malloc_memory (4, sizeof (int64_t), &nbytes) ;
544 CHECK (p != NULL) ;
545 GB_FREE (&p, nbytes) ;
546 CHECK (p == NULL) ;
547 p = GB_calloc_memory (4, sizeof (int64_t), &nbytes, NULL) ;
548 CHECK (p != NULL) ;
549 bool ok = true ;
550 p = GB_realloc_memory (6, 4, sizeof (int64_t), p, &nbytes, &ok, NULL) ;
551 CHECK (p != NULL) ;
552 CHECK (ok) ;
553 GB_FREE (&p, nbytes) ;
554 CHECK (p == NULL) ;
555
556 CHECK (!GB_Global_malloc_is_thread_safe_get ( )) ;
557 GB_Global_malloc_is_thread_safe_set (true) ;
558 CHECK (GB_Global_malloc_is_thread_safe_get ( )) ;
559 GB_Global_malloc_is_thread_safe_set (false) ;
560 CHECK (!GB_Global_malloc_is_thread_safe_get ( )) ;
561
562 GB_Global_malloc_tracking_set (true) ;
563
564 //--------------------------------------------------------------------------
565 // other global settings
566 //--------------------------------------------------------------------------
567
568 int64_t hack0 = GB_Global_hack_get (0) ;
569 int64_t hack1 = GB_Global_hack_get (1) ;
570
571 GB_Global_hack_set (0, 90123) ; CHECK (GB_Global_hack_get (0) == 90123) ;
572 GB_Global_hack_set (0, hack0) ; CHECK (GB_Global_hack_get (0) == hack0) ;
573 GB_Global_hack_set (1, 99123) ; CHECK (GB_Global_hack_get (1) == 99123) ;
574 GB_Global_hack_set (1, hack1) ; CHECK (GB_Global_hack_get (1) == hack1) ;
575
576 GrB_Info expected = GrB_INVALID_VALUE ;
577
578 //--------------------------------------------------------------------------
579 // GB_pslice
580 //--------------------------------------------------------------------------
581
582 int64_t Slice [30] ;
583 GB_pslice (Slice, NULL, 0, 4, true) ;
584 for (int t = 0 ; t < 4 ; t++) CHECK (Slice [t] == 0) ;
585
586 //--------------------------------------------------------------------------
587 // renamed boolean monoids
588 //--------------------------------------------------------------------------
589
590 GrB_Monoid mono = NULL ;
591
592 // DIV renamed to FIRST
593 OK (GrB_Monoid_new_BOOL_(&mono, GrB_DIV_BOOL, (bool) false)) ;
594 printf ("\ndiv_bool monoid:\n") ;
595 OK (GxB_Monoid_fprint_(mono, GxB_COMPLETE, NULL)) ;
596 GrB_Monoid_free_(&mono) ;
597
598 // RDIV renamed to SECOND
599 OK (GrB_Monoid_new_BOOL_(&mono, GxB_RDIV_BOOL, (bool) false)) ;
600 printf ("\nrdiv_bool monoid:\n") ;
601 OK (GxB_Monoid_fprint_(mono, GxB_COMPLETE, NULL)) ;
602 GrB_Monoid_free_(&mono) ;
603
604 // ISGT renamed to GT
605 OK (GrB_Monoid_new_BOOL_(&mono, GxB_ISGT_BOOL, (bool) false)) ;
606 printf ("\nisgt_bool monoid:\n") ;
607 OK (GxB_Monoid_fprint_(mono, GxB_COMPLETE, NULL)) ;
608 GrB_Monoid_free_(&mono) ;
609
610 // ISLT renamed to LT
611 OK (GrB_Monoid_new_BOOL_(&mono, GxB_ISLT_BOOL, (bool) false)) ;
612 printf ("\nislt_bool monoid:\n") ;
613 OK (GxB_Monoid_fprint_(mono, GxB_COMPLETE, NULL)) ;
614 GrB_Monoid_free_(&mono) ;
615
616 // ISGE renamed to GE
617 OK (GrB_Monoid_new_BOOL_(&mono, GxB_ISGE_BOOL, (bool) false)) ;
618 printf ("\nisge_bool monoid:\n") ;
619 OK (GxB_Monoid_fprint_(mono, GxB_COMPLETE, NULL)) ;
620 GrB_Monoid_free_(&mono) ;
621
622 // ISLE renamed to LE
623 OK (GrB_Monoid_new_BOOL_(&mono, GxB_ISLE_BOOL, (bool) false)) ;
624 printf ("\nisle_bool monoid:\n") ;
625 OK (GxB_Monoid_fprint_(mono, GxB_COMPLETE, NULL)) ;
626 GrB_Monoid_free_(&mono) ;
627
628 //--------------------------------------------------------------------------
629 // select
630 //--------------------------------------------------------------------------
631
632 GrB_Type user_type = NULL ;
633 OK (GrB_Type_new (&user_type, sizeof (user_int))) ;
634 OK (GrB_Type_wait_(&user_type)) ;
635 OK (GrB_Matrix_new (&A, user_type, 10, 10)) ;
636 OK (GrB_Matrix_new (&B, GrB_INT16, 10, 10)) ;
637 user_int value ;
638 for (int i = 0 ; i < 10 ; i++)
639 {
640 value = (int64_t) i ;
641 OK (GrB_Matrix_setElement_UDT (A, &value, i, i)) ;
642 OK (GrB_Matrix_setElement_INT16 (B, i, i, i)) ;
643 }
644 OK (GrB_Matrix_wait_(&A)) ;
645 OK (GrB_Matrix_wait_(&B)) ;
646 OK (GxB_Matrix_fprint_(A, GxB_COMPLETE, NULL)) ;
647 OK (GxB_Matrix_fprint_(B, GxB_COMPLETE, NULL)) ;
648
649 GxB_Scalar thunk = NULL ;
650 OK (GxB_Scalar_new (&thunk, user_type)) ;
651 GrB_Type type2 = NULL ;
652 OK (GxB_Scalar_type (&type2, thunk)) ;
653 CHECK (type2 == user_type) ;
654 OK (GxB_Scalar_fprint_(thunk, GxB_COMPLETE, NULL)) ;
655 OK (GxB_Matrix_select_(A, NULL, NULL, GxB_NE_THUNK, A, thunk, NULL)) ;
656
657 value = (int64_t) 4 ;
658 OK (GxB_Scalar_setElement_UDT (thunk, &value)) ;
659
660 expected = GrB_DOMAIN_MISMATCH ;
661 ERR1 (A, GxB_Matrix_select_(A, NULL, NULL, GxB_GE_THUNK, A, thunk, NULL)) ;
662 GrB_Matrix_error_(&err, A) ;
663 printf ("Expected error: info: %d\n%s\n", info, err) ;
664
665 GxB_Scalar thunk2 = NULL ;
666 OK (GxB_Scalar_new (&thunk2, GrB_INT16)) ;
667 OK (GxB_Scalar_setElement_INT16 (thunk2, 4)) ;
668 OK (GxB_Scalar_wait_(&thunk2)) ;
669
670 expected = GrB_DOMAIN_MISMATCH ;
671
672 ERR1 (A, GxB_Matrix_select_(A, NULL, NULL, GxB_GE_ZERO, A, NULL, NULL)) ;
673 GrB_Matrix_error_(&err, A) ;
674 printf ("Expected error: info: %d\n%s\n", info, err) ;
675
676 ERR1 (A, GxB_Matrix_select_(A, NULL, NULL, GxB_GT_ZERO, A, NULL, NULL)) ;
677 GrB_Matrix_error_(&err, A) ;
678 printf ("Expected error: info: %d\n%s\n", info, err) ;
679
680 ERR1 (A, GxB_Matrix_select_(A, NULL, NULL, GxB_LT_ZERO, A, NULL, NULL)) ;
681 GrB_Matrix_error_(&err, A) ;
682 printf ("Expected error: info: %d\n%s\n", info, err) ;
683
684 ERR1 (A, GxB_Matrix_select_(A, NULL, NULL, GxB_LE_ZERO, A, NULL, NULL)) ;
685 GrB_Matrix_error_(&err, A) ;
686 printf ("Expected error: info: %d\n%s\n", info, err) ;
687
688 ERR1 (B, GxB_Matrix_select_(B, NULL, NULL, GxB_LE_THUNK, B, thunk, NULL)) ;
689 GrB_Matrix_error_(&err, A) ;
690 printf ("Expected error: info: %d\n%s\n", info, err) ;
691 GrB_Matrix_free_(&B) ;
692
693 OK (GrB_Matrix_new (&B, user_type, 10, 10)) ;
694 printf ("\n============== B = select (A != 0)\n") ;
695 OK (GxB_Matrix_select_(B, NULL, NULL, GxB_NONZERO, A, NULL, NULL)) ;
696 OK (GxB_Matrix_fprint_(B, GxB_COMPLETE, NULL)) ;
697 printf ("\n============== B = select (A == 0)\n") ;
698 OK (GxB_Matrix_select_(B, NULL, NULL, GxB_EQ_ZERO, A, NULL, NULL)) ;
699 OK (GxB_Matrix_fprint_(B, GxB_COMPLETE, NULL)) ;
700 printf ("\n============== B = select (A != 4)\n") ;
701 OK (GxB_Matrix_select_(B, NULL, NULL, GxB_NE_THUNK, A, thunk, NULL)) ;
702 OK (GxB_Matrix_fprint_(B, GxB_COMPLETE, NULL)) ;
703 printf ("\n============== B = select (A == 4)\n") ;
704 OK (GxB_Matrix_select_(B, NULL, NULL, GxB_EQ_THUNK, A, thunk, NULL)) ;
705 OK (GxB_Matrix_fprint_(B, GxB_COMPLETE, NULL)) ;
706
707 GrB_Matrix_free_(&B) ;
708 GrB_Matrix_free_(&A) ;
709 GxB_Scalar_free_(&thunk) ;
710 GxB_Scalar_free_(&thunk2) ;
711 GrB_Type_free_(&user_type) ;
712
713 OK (GrB_Matrix_new (&A, GrB_BOOL, 10, 10)) ;
714 OK (GrB_Matrix_new (&B, GrB_BOOL, 10, 10)) ;
715 OK (GxB_Scalar_new (&thunk, GrB_BOOL)) ;
716 OK (GxB_Scalar_setElement_BOOL (thunk, 0)) ;
717 for (int i = 0 ; i < 10 ; i++)
718 {
719 OK (GrB_Matrix_setElement_BOOL_(A, (bool) (i % 2), i, i)) ;
720 }
721 OK (GrB_Matrix_wait_(&A)) ;
722 OK (GxB_Matrix_fprint_(A, GxB_COMPLETE, NULL)) ;
723
724 printf ("\n============== B = select (A > 0)\n") ;
725 OK (GxB_Matrix_select_(B, NULL, NULL, GxB_GT_THUNK, A, thunk, NULL)) ;
726 OK (GxB_Matrix_fprint_(B, GxB_COMPLETE, NULL)) ;
727 printf ("\n============== B = select (A >= 0)\n") ;
728 OK (GxB_Matrix_select_(B, NULL, NULL, GxB_GE_THUNK, A, thunk, NULL)) ;
729 OK (GxB_Matrix_fprint_(B, GxB_COMPLETE, NULL)) ;
730 printf ("\n============== B = select (A < 0)\n") ;
731 OK (GxB_Matrix_select_(B, NULL, NULL, GxB_LT_THUNK, A, thunk, NULL)) ;
732 OK (GxB_Matrix_fprint_(B, GxB_COMPLETE, NULL)) ;
733 printf ("\n============== B = select (A <= 0)\n") ;
734 OK (GxB_Matrix_select_(B, NULL, NULL, GxB_LE_THUNK, A, thunk, NULL)) ;
735 OK (GxB_Matrix_fprint_(B, GxB_COMPLETE, NULL)) ;
736
737 GrB_Matrix_free_(&B) ;
738 GrB_Matrix_free_(&A) ;
739 GxB_Scalar_free_(&thunk) ;
740
741 //--------------------------------------------------------------------------
742 // create a test matrix
743 //--------------------------------------------------------------------------
744
745 OK (GrB_Matrix_new (&A, GrB_FP64, 8, 8)) ;
746 for (int i = 0 ; i < 8 ; i++)
747 {
748 for (int j = 0 ; j < 8 ; j++)
749 {
750 OK (GrB_Matrix_setElement_FP64 (A, i*100+j, i, j)) ;
751 }
752 }
753 OK (GrB_Matrix_wait_(&A)) ;
754
755 GrB_Vector_new (&victor, GrB_FP64, 43) ;
756 OK (GrB_Vector_setElement_FP64 (victor, 99, 0)) ;
757 OK (GrB_Vector_wait_(&victor)) ;
758
759 //--------------------------------------------------------------------------
760 // GxB_get
761 //--------------------------------------------------------------------------
762
763 int sparsity ;
764 OK (GxB_Matrix_Option_get_(A, GxB_SPARSITY_CONTROL, &sparsity)) ;
765 CHECK (sparsity == GxB_AUTO_SPARSITY) ;
766 OK (GxB_Vector_Option_get_(victor, GxB_SPARSITY_CONTROL, &sparsity)) ;
767 CHECK (sparsity == GxB_AUTO_SPARSITY) ;
768 OK (GxB_Vector_Option_get_(victor, GxB_SPARSITY_STATUS, &sparsity)) ;
769 CHECK (sparsity == GxB_SPARSE) ;
770 GxB_Format_Value fmt ;
771 OK (GxB_Vector_Option_get_(victor, GxB_FORMAT, &fmt)) ;
772 CHECK (fmt == GxB_BY_COL) ;
773 bool is_hyper ;
774 OK (GxB_Vector_Option_get_(victor, GxB_IS_HYPER, &is_hyper)) ;
775 CHECK (!is_hyper) ;
776 expected = GrB_INVALID_VALUE ;
777 ERR (GxB_Vector_Option_get_(victor, -999, &is_hyper)) ;
778
779 //--------------------------------------------------------------------------
780 // GxB_set
781 //--------------------------------------------------------------------------
782
783 ERR (GxB_Vector_Option_set_(victor, -999, &is_hyper)) ;
784 OK (GxB_Vector_Option_set_(victor, GxB_SPARSITY_CONTROL, 9999)) ;
785 OK (GxB_Vector_Option_get_(victor, GxB_SPARSITY_CONTROL, &sparsity)) ;
786 CHECK (sparsity == GxB_AUTO_SPARSITY) ;
787
788 //--------------------------------------------------------------------------
789 // removeElement errors
790 //--------------------------------------------------------------------------
791
792 expected = GrB_INVALID_INDEX ;
793 ERR1 (victor, GrB_Vector_removeElement (victor, 9999)) ;
794 GrB_Vector_error_(&err, victor) ;
795 printf ("expected error: %s\n", err) ;
796 ERR1 (A, GrB_Matrix_removeElement (A, 0, 9999)) ;
797 GrB_Matrix_error_(&err, A) ;
798 printf ("expected error: %s\n", err) ;
799 ERR1 (A, GrB_Matrix_removeElement (A, 9999, 0)) ;
800 GrB_Matrix_error_(&err, A) ;
801 printf ("expected error: %s\n", err) ;
802
803 //--------------------------------------------------------------------------
804 // pending tuples
805 //--------------------------------------------------------------------------
806
807 GrB_Matrix_free_(&A) ;
808 OK (GrB_Matrix_new (&A, GrB_FP64, 8, 8)) ;
809
810 GrB_Index I [1] = { 0 }, J [1] = { 0 } ;
811 OK (GrB_Matrix_assign_FP64_(A, NULL, GrB_PLUS_FP64,
812 (double) 2, I, 1, J, 1, NULL)) ;
813 GxB_Matrix_fprint_(A, GxB_COMPLETE, NULL) ;
814 OK (GrB_Matrix_setElement_FP64_(A, (double) 3, 0, 0)) ;
815 GxB_Matrix_fprint_(A, GxB_COMPLETE, NULL) ;
816 OK (GrB_Matrix_wait_(&A)) ;
817 GxB_Matrix_fprint_(A, GxB_COMPLETE, NULL) ;
818
819 GrB_Matrix_free_(&A) ;
820 GrB_Vector_free_(&victor) ;
821
822 //--------------------------------------------------------------------------
823 // remvoe element with empty matrix and vector
824 //--------------------------------------------------------------------------
825
826 printf ("testing removeElement\n") ;
827 OK (GrB_Vector_new (&victor, GrB_FP64, 4)) ;
828 OK (GrB_Matrix_new (&A, GrB_FP64, 4, 4)) ;
829 OK (GrB_Vector_removeElement (victor, 0)) ;
830 OK (GrB_Matrix_removeElement (A, 0, 0)) ;
831 GrB_Matrix_free_(&A) ;
832 GrB_Vector_free_(&victor) ;
833 printf ("removeElement: OK\n") ;
834
835 //--------------------------------------------------------------------------
836 // select error handling
837 //--------------------------------------------------------------------------
838
839 GxB_SelectOp selectop = NULL ;
840 OK (GxB_SelectOp_new (&selectop, select_plus_one, GrB_FP64, GrB_FP64)) ;
841 OK (GxB_SelectOp_wait_(&selectop)) ;
842 OK (GrB_Matrix_new (&A, GrB_FP64, 8, 8)) ;
843 OK (GrB_Matrix_new (&C, GrB_FP64, 8, 8)) ;
844 for (int i = 0 ; i < 8 ; i++)
845 {
846 OK (GrB_Matrix_setElement_FP64 (A, i, i, i)) ;
847 }
848 OK (GxB_Matrix_fprint_(A, GxB_COMPLETE, NULL)) ;
849 OK (GxB_Scalar_new (&thunk, GrB_FP64)) ;
850 OK (GxB_Scalar_setElement_FP64 (thunk, 4)) ;
851 OK (GxB_Matrix_select_(C, NULL, NULL, selectop, A, thunk, NULL)) ;
852
853 printf ("\nprint in one-based, long format:\n") ;
854 GB_Global_print_one_based_set (true) ;
855 OK (GxB_Matrix_fprint_(C, GxB_COMPLETE_VERBOSE, NULL)) ;
856 GB_Global_print_one_based_set (false) ;
857
858 expected = GrB_NULL_POINTER ;
859 ERR1 (C, GxB_Matrix_select_(C, NULL, NULL, selectop, A, NULL, NULL)) ;
860 GrB_Matrix_error_(&err, C) ;
861 printf ("Error expected: %d\n%s\n", info, err) ;
862
863 expected = GrB_INVALID_VALUE ;
864 OK (GxB_Scalar_clear (thunk)) ;
865 ERR1 (C, GxB_Matrix_select_(C, NULL, NULL, selectop, A, thunk, NULL)) ;
866 GrB_Matrix_error_(&err, C) ;
867 printf ("Error expected: %d\n%s\n", info, err) ;
868
869 expected = GrB_DOMAIN_MISMATCH ;
870 GxB_Scalar_free_(&thunk) ;
871 OK (GxB_Scalar_new (&thunk, GrB_FP32)) ;
872 ERR1 (C, GxB_Matrix_select_(C, NULL, NULL, selectop, A, thunk, NULL)) ;
873 GrB_Matrix_error_(&err, C) ;
874 printf ("Error expected: %d\n%s\n", info, err) ;
875
876 GxB_SelectOp_free_(&selectop) ;
877 OK (GxB_SelectOp_new (&selectop, select_nothing, GrB_FP64, NULL)) ;
878 ERR1 (C, GxB_Matrix_select_(C, NULL, NULL, selectop, A, thunk, NULL)) ;
879 GrB_Matrix_error_(&err, C) ;
880 printf ("Error expected: %d\n%s\n", info, err) ;
881
882 expected = GrB_UNINITIALIZED_OBJECT ;
883 OK (GrB_Type_new (&user_type, sizeof (user_int))) ;
884 user_type->magic = 0xDEAD ;
885 ERR (GxB_Type_fprint_(user_type, GxB_COMPLETE, NULL)) ;
886 expected = GrB_INVALID_OBJECT ;
887 selectop->ttype = user_type ;
888 ERR (GxB_SelectOp_fprint_(selectop, GxB_COMPLETE, NULL)) ;
889 user_type->magic = GB_MAGIC ;
890
891 expected = GrB_UNINITIALIZED_OBJECT ;
892 thunk->magic = 0xDEAD ;
893 ERR (GxB_Scalar_fprint_(thunk, GxB_COMPLETE, NULL)) ;
894 thunk->magic = GB_MAGIC ;
895 printf ("Error expected: %d\n", info) ;
896
897 GrB_Matrix_free_(&A) ;
898 GrB_Matrix_free_(&C) ;
899 GxB_Scalar_free_(&thunk) ;
900 GxB_SelectOp_free_(&selectop) ;
901
902 //--------------------------------------------------------------------------
903 // GxB_Scalar
904 //--------------------------------------------------------------------------
905
906 GrB_Index nvals = 42 ;
907 GxB_Scalar scalar = NULL, scalar2 = NULL ;
908 OK (GxB_Scalar_new (&scalar, GrB_FP64)) ;
909 OK (GxB_Scalar_nvals (&nvals, scalar)) ;
910 OK (GxB_Scalar_wait_(&scalar)) ;
911 CHECK (nvals == 0) ;
912
913 bool b_8 = 0 ;
914 int8_t i_8 = 0 ;
915 int16_t i_16 = 0 ;
916 int32_t i_32 = 0 ;
917 int64_t i_64 = 0 ;
918 uint8_t u_8 = 0 ;
919 uint16_t u_16 = 0 ;
920 uint32_t u_32 = 0 ;
921 uint64_t u_64 = 0 ;
922 float x_32 = 0 ;
923 double x_64 = 0 ;
924
925 OK (GxB_Scalar_setElement_FP64_(scalar, (double) 1.25)) ;
926 OK (GxB_Scalar_nvals (&nvals, scalar)) ;
927 OK (GxB_Scalar_wait_(&scalar)) ;
928 CHECK (nvals == 1) ;
929
930 OK (GxB_Scalar_dup (&scalar2, scalar)) ;
931 OK (GxB_Scalar_fprint_(scalar2, GxB_COMPLETE, NULL)) ;
932
933 OK (GxB_Scalar_extractElement_BOOL_(&b_8, scalar)) ; CHECK (b_8 == 1) ;
934
935 OK (GxB_Scalar_extractElement_INT8_ (&i_8, scalar)) ; CHECK (i_8 == 1) ;
936 OK (GxB_Scalar_extractElement_INT16_(&i_16, scalar)) ; CHECK (i_16 == 1) ;
937 OK (GxB_Scalar_extractElement_INT32_(&i_32, scalar)) ; CHECK (i_32 == 1) ;
938 OK (GxB_Scalar_extractElement_INT64_(&i_64, scalar)) ; CHECK (i_64 == 1) ;
939
940 OK (GxB_Scalar_extractElement_UINT8_ (&u_8, scalar)) ; CHECK (u_8 == 1) ;
941 OK (GxB_Scalar_extractElement_UINT16_(&u_16, scalar)) ; CHECK (u_16 == 1) ;
942 OK (GxB_Scalar_extractElement_UINT32_(&u_32, scalar)) ; CHECK (u_32 == 1) ;
943 OK (GxB_Scalar_extractElement_UINT64_(&u_64, scalar)) ; CHECK (u_64 == 1) ;
944
945 OK (GxB_Scalar_extractElement_FP32_(&x_32, scalar)) ; CHECK (x_32 == 1.25) ;
946 OK (GxB_Scalar_extractElement_FP64_(&x_64, scalar)) ; CHECK (x_64 == 1.25) ;
947
948 OK (GxB_Scalar_clear (scalar)) ;
949 info = GxB_Scalar_extractElement_FP64_(&x_64, scalar) ;
950 CHECK (info == GrB_NO_VALUE) ;
951 CHECK (x_64 == 1.25) ;
952
953 info = GrB_Matrix_extractElement_FP64_(&x_64, (GrB_Matrix) scalar, 0, 0) ;
954 CHECK (info == GrB_NO_VALUE) ;
955 CHECK (x_64 == 1.25) ;
956
957 info = GrB_Vector_extractElement_FP64_(&x_64, (GrB_Vector) scalar, 0) ;
958 CHECK (info == GrB_NO_VALUE) ;
959 CHECK (x_64 == 1.25) ;
960
961 u_64 = 0 ;
962 OK (GxB_Scalar_extractElement_UINT64_(&u_64, scalar2)) ; CHECK (u_64 == 1) ;
963 OK (GxB_Scalar_nvals (&nvals, scalar2)) ;
964 OK (GxB_Scalar_wait_(&scalar2)) ;
965 CHECK (nvals == 1) ;
966
967 expected = GrB_INVALID_OBJECT ;
968 scalar2->vlen = 2 ;
969 ERR (GxB_Scalar_fprint_(scalar2, GxB_COMPLETE, NULL)) ;
970 scalar2->vlen = 1 ;
971 OK (GxB_Scalar_fprint_(scalar2, GxB_COMPLETE, NULL)) ;
972
973 GxB_Scalar_free_(&scalar) ;
974 GxB_Scalar_free_(&scalar2) ;
975
976 //--------------------------------------------------------------------------
977 // predefined descriptors
978 //--------------------------------------------------------------------------
979
980 OK (GxB_Descriptor_fprint (GrB_DESC_T1 , "T1 ", GxB_COMPLETE, NULL));
981 OK (GxB_Descriptor_fprint (GrB_DESC_T0 , "T0 ", GxB_COMPLETE, NULL));
982 OK (GxB_Descriptor_fprint (GrB_DESC_T0T1 , "T0T1 ", GxB_COMPLETE, NULL));
983 OK (GxB_Descriptor_fprint (GrB_DESC_C , "C ", GxB_COMPLETE, NULL));
984 OK (GxB_Descriptor_fprint (GrB_DESC_CT1 , "CT1 ", GxB_COMPLETE, NULL));
985 OK (GxB_Descriptor_fprint (GrB_DESC_CT0 , "CT0 ", GxB_COMPLETE, NULL));
986 OK (GxB_Descriptor_fprint (GrB_DESC_CT0T1 , "CT0T1 ", GxB_COMPLETE, NULL));
987 OK (GxB_Descriptor_fprint (GrB_DESC_S , "S ", GxB_COMPLETE, NULL));
988 OK (GxB_Descriptor_fprint (GrB_DESC_ST1 , "ST1 ", GxB_COMPLETE, NULL));
989 OK (GxB_Descriptor_fprint (GrB_DESC_ST0 , "ST0 ", GxB_COMPLETE, NULL));
990 OK (GxB_Descriptor_fprint (GrB_DESC_ST0T1 , "ST0T1 ", GxB_COMPLETE, NULL));
991 OK (GxB_Descriptor_fprint (GrB_DESC_SC , "SC ", GxB_COMPLETE, NULL));
992 OK (GxB_Descriptor_fprint (GrB_DESC_SCT1 , "SCT1 ", GxB_COMPLETE, NULL));
993 OK (GxB_Descriptor_fprint (GrB_DESC_SCT0 , "SCT0 ", GxB_COMPLETE, NULL));
994 OK (GxB_Descriptor_fprint (GrB_DESC_SCT0T1 , "SCT0T1", GxB_COMPLETE, NULL));
995 OK (GxB_Descriptor_fprint (GrB_DESC_R , "R ", GxB_COMPLETE, NULL));
996 OK (GxB_Descriptor_fprint (GrB_DESC_RT1 , "RT1 ", GxB_COMPLETE, NULL));
997 OK (GxB_Descriptor_fprint (GrB_DESC_RT0 , "RT0 ", GxB_COMPLETE, NULL));
998 OK (GxB_Descriptor_fprint (GrB_DESC_RT0T1 , "RT0T1 ", GxB_COMPLETE, NULL));
999 OK (GxB_Descriptor_fprint (GrB_DESC_RC , "RC ", GxB_COMPLETE, NULL));
1000 OK (GxB_Descriptor_fprint (GrB_DESC_RCT1 , "RCT1 ", GxB_COMPLETE, NULL));
1001 OK (GxB_Descriptor_fprint (GrB_DESC_RCT0 , "RCT0 ", GxB_COMPLETE, NULL));
1002 OK (GxB_Descriptor_fprint (GrB_DESC_RCT0T1 , "RCT0T1", GxB_COMPLETE, NULL));
1003 OK (GxB_Descriptor_fprint (GrB_DESC_RS , "RS ", GxB_COMPLETE, NULL));
1004 OK (GxB_Descriptor_fprint (GrB_DESC_RST1 , "RST1 ", GxB_COMPLETE, NULL));
1005 OK (GxB_Descriptor_fprint (GrB_DESC_RST0 , "RST0 ", GxB_COMPLETE, NULL));
1006 OK (GxB_Descriptor_fprint (GrB_DESC_RST0T1 , "RST0T1", GxB_COMPLETE, NULL));
1007 OK (GxB_Descriptor_fprint (GrB_DESC_RSC , "RSC ", GxB_COMPLETE, NULL));
1008 OK (GxB_Descriptor_fprint (GrB_DESC_RSCT1 , "RSCT1 ", GxB_COMPLETE, NULL));
1009 OK (GxB_Descriptor_fprint (GrB_DESC_RSCT0 , "RSCT0 ", GxB_COMPLETE, NULL));
1010 OK (GxB_Descriptor_fprint (GrB_DESC_RSCT0T1, "RSCT0T1",GxB_COMPLETE, NULL));
1011
1012 GrB_Descriptor_new (&Duh) ;
1013 OK (GxB_Desc_set (Duh, GxB_AxB_METHOD, GxB_AxB_SAXPY)) ;
1014 OK (GxB_Descriptor_fprint_(Duh, GxB_COMPLETE, NULL)) ;
1015 OK (GxB_Desc_set (Duh, GxB_AxB_METHOD, GxB_AxB_HASH)) ;
1016 OK (GxB_Descriptor_fprint_(Duh, GxB_COMPLETE, NULL)) ;
1017 OK (GxB_Desc_set (Duh, GxB_AxB_METHOD, GxB_AxB_GUSTAVSON)) ;
1018 OK (GxB_Descriptor_fprint_(Duh, GxB_COMPLETE, NULL)) ;
1019 OK (GxB_Desc_set (Duh, GxB_AxB_METHOD, GxB_AxB_DOT)) ;
1020 OK (GxB_Descriptor_fprint_(Duh, GxB_COMPLETE, NULL)) ;
1021 GrB_Descriptor_free_(&Duh) ;
1022
1023 expected = GrB_INVALID_VALUE ;
1024 ERR (GxB_Desc_set (GrB_DESC_S, GrB_INP0, GrB_TRAN)) ;
1025
1026 ERR (GrB_Descriptor_set (GrB_DESC_S, GrB_INP0, GrB_TRAN)) ;
1027
1028 //--------------------------------------------------------------------------
1029 // burble
1030 //--------------------------------------------------------------------------
1031
1032 bool burble ;
1033 OK (GxB_Global_Option_get_(GxB_BURBLE, &burble)) ;
1034 printf ("burble: %d\n", burble) ;
1035
1036 //--------------------------------------------------------------------------
1037 // select ops
1038 //--------------------------------------------------------------------------
1039
1040 OK (GxB_SelectOp_fprint (GxB_TRIL, "tril" , GxB_COMPLETE, NULL)) ;
1041 OK (GxB_SelectOp_fprint (GxB_TRIU, "triu" , GxB_COMPLETE, NULL)) ;
1042 OK (GxB_SelectOp_fprint (GxB_DIAG, "diag" , GxB_COMPLETE, NULL)) ;
1043 OK (GxB_SelectOp_fprint (GxB_OFFDIAG, "offidiag", GxB_COMPLETE, NULL)) ;
1044 OK (GxB_SelectOp_fprint (GxB_NONZERO, "nonzero" , GxB_COMPLETE, NULL)) ;
1045 OK (GxB_SelectOp_fprint (GxB_EQ_ZERO, "eq_zero" , GxB_COMPLETE, NULL)) ;
1046 OK (GxB_SelectOp_fprint (GxB_GT_ZERO, "gt_zero" , GxB_COMPLETE, NULL)) ;
1047 OK (GxB_SelectOp_fprint (GxB_GE_ZERO, "ge_zero" , GxB_COMPLETE, NULL)) ;
1048 OK (GxB_SelectOp_fprint (GxB_LT_ZERO, "lt_zero" , GxB_COMPLETE, NULL)) ;
1049 OK (GxB_SelectOp_fprint (GxB_LE_ZERO, "le_zero" , GxB_COMPLETE, NULL)) ;
1050 OK (GxB_SelectOp_fprint (GxB_NE_THUNK, "ne_thunk", GxB_COMPLETE, NULL)) ;
1051 OK (GxB_SelectOp_fprint (GxB_EQ_THUNK, "eq_thunk", GxB_COMPLETE, NULL)) ;
1052 OK (GxB_SelectOp_fprint (GxB_GT_THUNK, "gt_thunk", GxB_COMPLETE, NULL)) ;
1053 OK (GxB_SelectOp_fprint (GxB_GE_THUNK, "ge_thunk", GxB_COMPLETE, NULL)) ;
1054 OK (GxB_SelectOp_fprint (GxB_LT_THUNK, "lt_thunk", GxB_COMPLETE, NULL)) ;
1055 OK (GxB_SelectOp_fprint (GxB_LE_THUNK, "le_thunk", GxB_COMPLETE, NULL)) ;
1056
1057 //--------------------------------------------------------------------------
1058 // assign scalar into hypersparse
1059 //--------------------------------------------------------------------------
1060
1061 GrB_Index n = INT32_MAX ;
1062 n = n * 1024 ;
1063 OK (GrB_Matrix_new (&A, GrB_FP64, n, n)) ;
1064 expected = GrB_OUT_OF_MEMORY ;
1065 ERR1 (A, GrB_Matrix_assign_FP64_(A, NULL, NULL, (double) 1,
1066 GrB_ALL, n, GrB_ALL, n, NULL)) ;
1067 GrB_Matrix_error_(&err, A) ;
1068 printf ("\nproblem too large, expected error: %s\n", err) ;
1069 OK (GrB_Matrix_free_(&A)) ;
1070
1071 //--------------------------------------------------------------------------
1072 // setElement typecast
1073 //--------------------------------------------------------------------------
1074
1075 OK (GrB_Matrix_new (&A, user_type, 10, 10)) ;
1076
1077 expected = GrB_DOMAIN_MISMATCH ;
1078
1079 ERR1 (A, GrB_Matrix_setElement_BOOL (A, 0, 0, 0)) ;
1080 GrB_Matrix_error_(&err, A) ; printf ("expected: %s\n", err) ;
1081 ERR1 (A, GrB_Matrix_setElement_INT8 (A, 0, 0, 0)) ;
1082 GrB_Matrix_error_(&err, A) ; printf ("expected: %s\n", err) ;
1083 ERR1 (A, GrB_Matrix_setElement_INT16 (A, 0, 0, 0)) ;
1084 GrB_Matrix_error_(&err, A) ; printf ("expected: %s\n", err) ;
1085 ERR1 (A, GrB_Matrix_setElement_INT32 (A, 0, 0, 0)) ;
1086 GrB_Matrix_error_(&err, A) ; printf ("expected: %s\n", err) ;
1087 ERR1 (A, GrB_Matrix_setElement_INT64 (A, 0, 0, 0)) ;
1088 GrB_Matrix_error_(&err, A) ; printf ("expected: %s\n", err) ;
1089 ERR1 (A, GrB_Matrix_setElement_UINT8 (A, 0, 0, 0)) ;
1090 GrB_Matrix_error_(&err, A) ; printf ("expected: %s\n", err) ;
1091 ERR1 (A, GrB_Matrix_setElement_UINT16 (A, 0, 0, 0)) ;
1092 GrB_Matrix_error_(&err, A) ; printf ("expected: %s\n", err) ;
1093 ERR1 (A, GrB_Matrix_setElement_UINT32 (A, 0, 0, 0)) ;
1094 GrB_Matrix_error_(&err, A) ; printf ("expected: %s\n", err) ;
1095 ERR1 (A, GrB_Matrix_setElement_UINT64 (A, 0, 0, 0)) ;
1096 GrB_Matrix_error_(&err, A) ; printf ("expected: %s\n", err) ;
1097 ERR1 (A, GrB_Matrix_setElement_FP32 (A, 0, 0, 0)) ;
1098 GrB_Matrix_error_(&err, A) ; printf ("expected: %s\n", err) ;
1099 ERR1 (A, GrB_Matrix_setElement_FP64 (A, 0, 0, 0)) ;
1100 GrB_Matrix_error_(&err, A) ; printf ("expected: %s\n", err) ;
1101 ERR1 (A, GxB_Matrix_setElement_FC32 (A, GxB_CMPLXF(0,0), 0, 0)) ;
1102 GrB_Matrix_error_(&err, A) ; printf ("expected: %s\n", err) ;
1103 ERR1 (A, GxB_Matrix_setElement_FC64 (A, GxB_CMPLX (0,0), 0, 0)) ;
1104 GrB_Matrix_error_(&err, A) ; printf ("expected: %s\n", err) ;
1105
1106 //--------------------------------------------------------------------------
1107 // GrB_error
1108 //--------------------------------------------------------------------------
1109
1110 GrB_Type_error_(&err, user_type) ;
1111 CHECK (err != NULL && err [0] == '\0') ;
1112
1113 GrB_UnaryOp_error_(&err, GrB_AINV_FP32) ;
1114 CHECK (err != NULL && err [0] == '\0') ;
1115
1116 GrB_BinaryOp_error_(&err, GrB_PLUS_FP32) ;
1117 CHECK (err != NULL && err [0] == '\0') ;
1118
1119 GxB_SelectOp_error_(&err, GxB_TRIL) ;
1120 CHECK (err != NULL && err [0] == '\0') ;
1121
1122 GrB_Monoid_error_(&err, GrB_LOR_MONOID_BOOL) ;
1123 CHECK (err != NULL && err [0] == '\0') ;
1124
1125 GrB_Semiring_error_(&err, GrB_PLUS_TIMES_SEMIRING_FP32) ;
1126 CHECK (err != NULL && err [0] == '\0') ;
1127
1128 GrB_Descriptor_error_(&err, GrB_DESC_T0) ;
1129 CHECK (err != NULL && err [0] == '\0') ;
1130
1131 OK (GxB_Scalar_new (&scalar, GrB_FP32)) ;
1132 GxB_Scalar_error_(&err, scalar) ;
1133 CHECK (err != NULL && err [0] == '\0') ;
1134
1135 OK (GrB_Vector_new (&victor, GrB_FP32, 10)) ;
1136 GrB_Vector_error_(&err, victor) ;
1137 CHECK (err != NULL && err [0] == '\0') ;
1138
1139 int16_t fortytwo = 42 ;
1140 OK (GrB_Matrix_setElement_UDT (A, (void *) &fortytwo, 3, 7)) ;
1141 OK (GxB_Matrix_fprint_(A, GxB_COMPLETE, NULL)) ;
1142 GrB_Matrix_error_(&err, A) ;
1143 CHECK (err != NULL && err [0] == '\0') ;
1144
1145 GrB_Vector_free_(&victor) ;
1146 GxB_Scalar_free_(&scalar) ;
1147 GrB_Type_free_(&user_type) ;
1148 GrB_Matrix_free_(&A) ;
1149
1150 //--------------------------------------------------------------------------
1151 // test for problem too large in GB_bitmap_AxB_saxpy
1152 //--------------------------------------------------------------------------
1153
1154 n = INT32_MAX ;
1155 OK (GrB_Matrix_new (&A, GrB_FP32, n, 0)) ;
1156 OK (GrB_Matrix_new (&B, GrB_FP32, 0, n)) ;
1157 expected = GrB_OUT_OF_MEMORY ;
1158 bool ignore ;
1159 struct GB_Matrix_opaque G_header ;
1160 GrB_Matrix G = GB_clear_static_header (&G_header) ;
1161 ERR (GB_bitmap_AxB_saxpy (G, GxB_BITMAP, NULL, false, false, A, B,
1162 GrB_PLUS_TIMES_SEMIRING_FP32, false, &ignore, NULL)) ;
1163 GrB_Matrix_free_(&A) ;
1164 GrB_Matrix_free_(&B) ;
1165 CHECK (G->x == NULL) ;
1166
1167 //--------------------------------------------------------------------------
1168 // wrapup
1169 //--------------------------------------------------------------------------
1170
1171 // #include "GB_Test_about_mkl_template.c"
1172 GB_mx_put_global (true) ;
1173 fclose (f) ;
1174 printf ("\nAll errors printed above were expected.\n") ;
1175 printf ("GB_mex_about: all tests passed\n\n") ;
1176 }
1177
1178