1function gbtest33
2%GBTEST33 test spones, numel, nzmax, size, length, is*, ...
3% isempty, issparse, ...  ismatrix, isvector, isscalar, isnumeric,
4% isfloat, isreal, isinteger, islogical, isa.
5
6% SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
7% SPDX-License-Identifier: GPL-3.0-or-later
8
9rng ('default') ;
10
11fprintf ('gbtest33:\n') ;
12
13types = gbtest_types ;
14
15for k1 = 1:length(types)
16    type = types {k1} ;
17    fprintf ('%s ', type) ;
18
19    H = GrB (2^55, 2^55, type) ;
20    [m, n] = size (H) ;
21    assert (m == 2^55) ;
22    assert (n == 2^55) ;
23    assert (isequal (class (m), 'int64'))
24    assert (isequal (class (n), 'int64'))
25    s = size (H) ;
26    assert (isequal (s, [2^55 2^55])) ;
27    assert (isequal (class (s), 'int64'))
28
29    for k2 = 1:length(types)
30        type2 = types {k2} ;
31
32        for n = 0:3
33            for m = 0:3
34                A = 100 * rand (m, n) ;
35                A (A < 50) = 0 ;
36                S = sparse (A) ;
37
38                G = GrB (S, type) ;
39                G2 = spones (G, type2) ;
40                assert (isequal (GrB.type (G2), type2)) ;
41
42                C = double (G2) ;
43                assert (isequal (sparse (C), spones (S))) ;
44
45                assert (numel (G) == m*n) ;
46                assert (nzmax (G) == max (nnz (G), 1))
47                assert (isequal (size (G), [m n])) ;
48                [m1, n1]  = size (G) ;
49                assert (isequal ([m1 n1], [m n])) ;
50                if (m == 0 || n == 0)
51                    assert (isempty (G)) ;
52                else
53                    assert (length (G) == max (m, n)) ;
54                end
55                assert (isempty (G) == (m == 0 | n == 0)) ;
56                assert (issparse (G)) ;
57                assert (issparse (full (G))) ;
58                assert (ismatrix (G)) ;
59                assert (isnumeric (G)) ;
60                assert (isvector (G) == (m == 1 | n == 1)) ;
61                assert (isscalar (G) == (m == 1 & n == 1)) ;
62
63                isfl = contains (type, 'double') | contains (type, 'single') ;
64                assert (isfloat (G) == isfl) ;
65                assert (isreal (G) == (~contains (type, 'complex'))) ;
66                isint = isequal (type (1:3), 'int') | ...
67                        isequal (type (2:4), 'int') ;
68                assert (isinteger (G) == isint) ;
69                islog = isequal (type, 'logical') ;
70                assert (islogical (G) == islog) ;
71
72                assert (isa (G, 'GrB')) ;
73                assert (isa (G, 'numeric')) ;
74                assert (isa (G, 'float') == isfl) ;
75                assert (isa (G, 'integer') == isint) ;
76                assert (isa (G, 'logical') == islog) ;
77                assert (isa (G, type) == isequal (GrB.type (G), type)) ;
78            end
79        end
80    end
81end
82
83fprintf ('\ngbtest33: all tests passed\n') ;
84
85