1function test24(fulltest)
2%TEST24 test GrB_reduce
3% test24(fulltest); fulltest=1 if longer test, 0 for quick test
4
5% SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
6% SPDX-License-Identifier: Apache-2.0
7
8[binops, ~, add_ops, types, ~, ~] = GB_spec_opsall ;
9test_types = types.all ;
10accum_ops = binops.all ;
11
12rng ('default') ;
13
14if (nargin < 1)
15    fulltest = 0 ;
16end
17
18if (fulltest)
19    fprintf ('\ntest24: ----- exhaustive test of GrB_reduce_to_scalar and vector\n') ;
20    cset = 1:length (test_types) ;
21    aset = 1:length (test_types) ;
22else
23    fprintf ('\ntest24: ----- quick test of GrB_reduce_to_scalar and vector\n');
24    cset = 10 ;
25    aset = 11 ;
26end
27
28dt = struct ('inp0', 'tran') ;
29
30% class of the vector x
31for k1 = cset
32    cclass = test_types {k1}  ;
33    cin = GB_mex_cast (2, cclass) ;
34    % fprintf ('\n===================================  c class: %s\n',cclass) ;
35
36    % class of the matrix A
37    for k2 = aset
38        aclass = test_types {k2}  ;
39        % fprintf ('\n==================================A class: %s\n',aclass) ;
40        fprintf ('[%s %s]', cclass, aclass) ;
41
42        % create a matrix
43        for m = [1 10 25]
44            for n = [1 10 25]
45                fprintf ('.') ;
46                clear A
47                A.matrix = sprandn (m, n, 0.1) ;
48                A.class = aclass ;
49
50                clear B
51                B.matrix = sprandn (m*n, 1, 0.1) ;
52                B.class = aclass ;
53
54                clear xin
55                xin.matrix = sprandn (m, 1, 0.1) ;
56                xin.class = cclass ;
57
58                clear yin
59                yin.matrix = sprandn (n, 1, 0.1) ;
60                yin.class = cclass ;
61
62                % reduce operator
63                for k3 = 1:length(add_ops)
64                    if (k3 == 0)
65                        reduce_op = ''  ;
66                        ntypes = 1 ;
67                    else
68                        reduce_op = add_ops {k3}  ;
69                        ntypes = 1;length (test_types) ;
70                    end
71                    % fprintf ('reduce: %s\n', reduce_op) ;
72                    % reduce operator class
73
74                    for k4 = ntypes
75                        clear reduce
76                        if (~isempty (reduce_op))
77                            reduce_class = test_types {k4}  ;
78                            reduce.opname = reduce_op ;
79                            reduce.optype = reduce_class ;
80                        else
81                            reduce = '' ;
82                            reduce_class = '' ;
83                        end
84
85                        try
86                            [opname optype ztype xtype ytype] = ...
87                                GB_spec_operator (reduce) ;
88                        catch
89                            continue
90                        end
91
92                        if (~isequal (reduce_class, 'logical') && ...
93                            ( isequal (reduce_op, 'or') || ...
94                              isequal (reduce_op, 'and') || ...
95                              isequal (reduce_op, 'xor') || ...
96                              isequal (reduce_op, 'eq')))
97                            continue ;
98                        end
99
100                        identity = GB_spec_identity (reduce) ;
101
102                        % accum operator
103                        for k5 = 0:length(accum_ops)
104                            if (k5 == 0)
105                                accum_op = ''  ;
106                                ntypes = 1 ;
107                            else
108                                accum_op = accum_ops {k5}  ;
109                                ntypes = 1;length (test_types) ;
110                            end
111                            % accum operator class
112                            for k6 = ntypes
113                                clear accum
114                                if (~isempty (accum_op))
115                                    accum_class = test_types {k6}  ;
116                                    accum.opname = accum_op ;
117                                    accum.optype = accum_class ;
118                                else
119                                    accum = '' ;
120                                    accum_class = '' ;
121                                end
122
123                                if (GB_spec_is_positional (accum))
124                                    continue ;
125                                end
126
127                                try
128                                    [opname optype ztype xtype ytype] = GB_spec_operator (accum) ;
129                                catch
130                                    continue
131                                end
132
133                                % reduce matrix to scalar
134                                c  = GB_mex_reduce_to_scalar  (cin, accum, reduce, A) ;
135                                c3 = GB_spec_reduce_to_scalar (cin, accum, reduce, A) ;
136                                assert (isequal (c, c3))
137
138                                % reduce vector to scalar
139                                c  = GB_mex_reduce_to_scalar  (cin, accum, reduce, B) ;
140                                c3 = GB_spec_reduce_to_scalar (cin, accum, reduce, B) ;
141                                assert (isequal (c, c3))
142
143                                % row-wise reduce matrix to vector
144
145                                % no mask
146                                x  = GB_mex_reduce_to_vector  (xin, [ ], accum, reduce, A, [ ]) ;
147                                x3 = GB_spec_reduce_to_vector (xin, [ ], accum, reduce, A, [ ]) ;
148                                GB_spec_compare (x, x3, identity) ;
149
150                                % with mask
151                                mask = sprandn (m,1,0.3) ~= 0 ;
152                                x  = GB_mex_reduce_to_vector  (xin, mask, accum, reduce, A, [ ]) ;
153                                x3 = GB_spec_reduce_to_vector (xin, mask, accum, reduce, A, [ ]) ;
154                                GB_spec_compare (x, x3, identity) ;
155
156                                % col-wise reduce matrix to vector
157
158                                % no mask
159                                y  = GB_mex_reduce_to_vector  (yin, [ ], accum, reduce, A, dt) ;
160                                y3 = GB_spec_reduce_to_vector (yin, [ ], accum, reduce, A, dt) ;
161                                GB_spec_compare (y, y3, identity) ;
162
163                                % with mask
164                                mask = sprandn (n,1,0.3) ~= 0 ;
165                                y  = GB_mex_reduce_to_vector  (yin, mask, accum, reduce, A, dt) ;
166                                y3 = GB_spec_reduce_to_vector (yin, mask, accum, reduce, A, dt) ;
167                                GB_spec_compare (y, y3, identity) ;
168
169                            end
170                        end
171                    end
172                end
173            end
174        end
175    end
176end
177
178fprintf ('\ntest24: all tests passed\n') ;
179
180