1function gbtest40
2%GBTEST40 test sum, prod, max, min, any, all, norm
3
4% SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
5% SPDX-License-Identifier: GPL-3.0-or-later
6
7rng ('default')
8
9x = GrB.random (10, 1, inf, 'range', complex ([0 1])) ;
10s1 = norm (x, 2) ;
11s2 = norm (double (x), 2) ;
12assert (abs (s1-s2) < 1e-12) ;
13
14x = GrB.random (10, 1, inf, 'range', int16 ([1 16])) ;
15s1 = norm (x, 2) ;
16s2 = norm (double (x), 2) ;
17assert (abs (s1-s2) < 1e-6) ;
18
19s1 = norm (x, -inf) ;
20s2 = norm (double (x), -inf) ;
21assert (abs (s1-s2) < 1e-6) ;
22
23old = verLessThan ('matlab', '9.6') ;
24
25for trial = 1:3
26    for m = 1:3
27        for n = 1:3
28            fprintf ('.') ;
29            for d = [0.1 0.5 1]
30                for kind = 0:1
31
32                    if (d == 1)
33                        A = sparse (rand (m,n)) ;
34                    else
35                        A = sprand (m, n, d) ;
36                    end
37                    if (kind == 1)
38                        A = logical (A) ;
39                    end
40                    G = GrB (A) ;
41
42                    s1 = sum (A) ;
43                    s2 = sum (G) ;
44                    assert (norm (s1-double(s2), 1) < 1e-12) ;
45                    s1 = sum (A,1) ;
46                    s2 = sum (G,1) ;
47                    assert (norm (s1-double(s2), 1) < 1e-12) ;
48                    s1 = sum (A,2) ;
49                    s2 = sum (G,2) ;
50                    assert (norm (s1-double(s2), 1) < 1e-12) ;
51                    if (old)
52                        s1 = sum (sum (A)) ;
53                    else
54                        s1 = sum (A, 'all') ;
55                    end
56                    s2 = sum (G, 'all') ;
57                    assert (norm (s1-double(s2), 1) < 1e-12) ;
58
59                    s1 = prod (A) ;
60                    s2 = prod (G) ;
61                    assert (norm (s1-double(s2), 1) < 1e-12) ;
62                    s1 = prod (A,1) ;
63                    s2 = prod (G,1) ;
64                    assert (norm (s1-double(s2), 1) < 1e-12) ;
65                    s1 = prod (A,2) ;
66                    s2 = prod (G,2) ;
67                    assert (norm (s1-double(s2), 1) < 1e-12) ;
68                    if (old)
69                        s1 = prod (prod (A)) ;
70                    else
71                        s1 = prod (A, 'all') ;
72                    end
73                    s2 = prod (G, 'all') ;
74                    assert (norm (s1-double(s2), 1) < 1e-12) ;
75
76                    if (kind == 0)
77
78                        s1 = norm (A,1) ;
79                        s2 = norm (G,1) ;
80                        assert (abs (s1 - s2) < 1e-12) ;
81
82                        if (isvector (A))
83                            s1 = norm (A,2) ;
84                            s2 = norm (G,2) ;
85                            assert (abs (s1 - s2) < 1e-12) ;
86                            s1 = norm (A) ;
87                            s2 = norm (G) ;
88                            assert (abs (s1 - s2) < 1e-12) ;
89                        end
90
91                        s1 = norm (A,inf) ;
92                        s2 = norm (G,inf) ;
93                        assert (abs (s1 - s2) < 1e-12) ;
94
95                        s1 = norm (A,'fro') ;
96                        s2 = norm (G,'fro') ;
97                        assert (abs (s1 - s2) < 1e-12) ;
98
99                        if (isvector (A))
100                            s1 = norm (A,2) ;
101                            s2 = norm (G,2) ;
102                            assert (abs (s1 - s2) < 1e-12) ;
103                            s1 = norm (A,-inf) ;
104                            s2 = norm (G,-inf) ;
105                            assert (abs (s1 - s2) < 1e-12) ;
106                        end
107
108                        s1 = max (A) ;
109                        s2 = max (G) ;
110                        assert (gbtest_eq (s1, s2)) ;
111                        s1 = max (A, [ ], 1) ;
112                        s2 = max (G, [ ], 1) ;
113                        assert (gbtest_eq (s1, s2)) ;
114                        s1 = max (A, [ ], 2) ;
115                        s2 = max (G, [ ], 2) ;
116                        assert (gbtest_eq (s1, s2)) ;
117                        if (old)
118                            s1 = max (max (A)) ;
119                        else
120                            s1 = max (A,  [ ], 'all') ;
121                        end
122                        s2 = max (G,  [ ], 'all') ;
123                        assert (gbtest_eq (s1, s2)) ;
124
125                        s1 = max (A, 0.5) ;
126                        s2 = max (G, 0.5) ;
127                        assert (gbtest_eq (s1, s2)) ;
128                        s1 = max (A, -0.5) ;
129                        s2 = max (G, -0.5) ;
130                        assert (gbtest_eq (s1, s2)) ;
131                        s1 = max (0.3, A) ;
132                        s2 = max (0.3, G) ;
133                        assert (gbtest_eq (s1, s2)) ;
134                        s1 = max (-0.3, A) ;
135                        s2 = max (-0.3, G) ;
136                        assert (gbtest_eq (s1, s2)) ;
137
138                        s1 = min (A) ;
139                        s2 = min (G) ;
140                        assert (gbtest_eq (s1, s2)) ;
141                        s1 = min (A, [ ], 1) ;
142                        s2 = min (G, [ ], 1) ;
143                        assert (gbtest_eq (s1, s2)) ;
144                        assert (gbtest_eq (s1, s2)) ;
145                        if (old)
146                            s1 = min (min (A)) ;
147                        else
148                            s1 = min (A,  [ ], 'all') ;
149                        end
150                        s2 = min (G,  [ ], 'all') ;
151                        assert (gbtest_eq (s1, s2)) ;
152
153                        s1 = min (A, 0.5) ;
154                        s2 = min (G, 0.5) ;
155                        assert (gbtest_eq (s1, s2)) ;
156                        s1 = min (A, -0.5) ;
157                        s2 = min (G, -0.5) ;
158                        assert (gbtest_eq (s1, s2)) ;
159                        s1 = min (0.3, A) ;
160                        s2 = min (0.3, G) ;
161                        assert (gbtest_eq (s1, s2)) ;
162                        s1 = min (-0.3, A) ;
163                        s2 = min (-0.3, G) ;
164                        assert (gbtest_eq (s1, s2)) ;
165
166                    end
167
168                    s1 = any (A) ;
169                    s2 = any (G) ;
170                    assert (all (s1 == s2)) ;
171                    s1 = any (A,1) ;
172                    s2 = any (G,1) ;
173                    assert (all (s1 == s2)) ;
174                    s1 = any (A,2) ;
175                    s2 = any (G,2) ;
176                    assert (all (s1 == s2)) ;
177                    if (old)
178                        s1 = any (any (A)) ;
179                    else
180                        s1 = any (A, 'all') ;
181                    end
182                    s2 = any (G, 'all') ;
183                    assert (all (s1 == s2)) ;
184
185                    s1 = all (A) ;
186                    s2 = all (G) ;
187                    assert (all (s1 == s2)) ;
188                    s1 = all (A,1) ;
189                    s2 = all (G,1) ;
190                    assert (all (s1 == s2)) ;
191                    s1 = all (A,2) ;
192                    s2 = all (G,2) ;
193                    assert (all (s1 == s2)) ;
194                    if (old)
195                        s1 = all (all (A)) ;
196                    else
197                        s1 = all (A, 'all') ;
198                    end
199                    s2 = all (G, 'all') ;
200                    assert (all (s1 == s2)) ;
201
202                end
203            end
204        end
205    end
206end
207
208fprintf ('\ngbtest40: all tests passed\n') ;
209
210