1function test21b (fulltest)
2%TEST21B test GrB_assign
3
4% SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2021, All Rights Reserved.
5% SPDX-License-Identifier: Apache-2.0
6
7if (nargin < 1)
8    % do a short test, by default
9    fulltest = 0 ;
10end
11
12[binops, ~, ~, types, ~, ~] = GB_spec_opsall ;
13accum_ops = binops.all ;
14types = types.all ;
15
16dn = struct ;
17dt = struct ( 'inp0', 'tran' ) ;
18
19if (fulltest)
20    fprintf ('\ntest21b --------------exhaustive test of GB_mex_assign\n') ;
21    k1test = 0:length(accum_ops) ;
22else
23    fprintf ('\ntest21b --------------quick test of GB_mex_assign\n') ;
24    k1test = [0 4] ; % Was [0 2 4] ;
25end
26
27quick = 0 ;
28
29% try all accum
30for k1 = k1test
31    if (k1 == 0)
32        accum_op = ''  ;
33        ntypes = 1 ;
34    else
35        accum_op = accum_ops {k1}  ;
36        ntypes = length (types) ;
37    end
38    fprintf ('\naccum: [%s]', accum_op) ;
39
40    if (fulltest)
41        k2test = 1:ntypes ;
42    else
43        k2test = [1 11] ; % Was [1 2 11] ;
44    end
45
46    % try all types
47    for k2 = k2test % 1:ntypes
48    clear accum
49    if (~isempty (accum_op))
50        accum_type = types {k2}  ;
51        accum.opname = accum_op ;
52        accum.optype = accum_type ;
53    else
54        accum = '' ;
55        accum_type = '' ;
56    end
57
58    if (GB_spec_is_positional (accum))
59        continue ;
60    end
61
62    try
63        GB_spec_operator (accum) ;
64    catch
65        continue ;
66    end
67
68    rng (k1 * 100 + k2, 'v4') ;
69
70    for Mask_complement = [false true]
71
72    if (Mask_complement)
73        dn.mask = 'complement' ;
74        dt.mask = 'complement' ;
75    else
76        dn.mask = 'default' ;
77        dt.mask = 'default' ;
78    end
79
80    for C_replace = [true false]
81
82    if (C_replace)
83        % fprintf ('C_replace') ;
84        dn.outp = 'replace' ;
85        dt.outp = 'replace' ;
86    else
87        dn.outp = 'default' ;
88        dt.outp = 'default' ;
89    end
90
91    kk3 = randperm (length (types), 1) ;
92
93    % try all matrix types, to test casting
94    for k3 = kk3 % 1:length (types)
95    atype = types {k3}  ;
96
97    % try some matrices
98    for m = [1 5 10 ]
99    for n = [ 1 5 10 ]
100    for sm = [ -3 -2 -1 0 1 5 10 ]
101    if (sm > m)
102        continue
103    end
104
105    fprintf ('.') ;
106
107    for sn = [ 0 1 5 10 ]
108    if (sn > n)
109        continue
110    end
111    for scalar = [false true]
112
113    if (sm == -3)
114
115        % I = (m-2):-2:1
116        if (m < 5)
117            continue
118        end
119        clear I0
120        I0.begin = m-3 ;
121        I0.inc = -2 ;
122        I0.end = 0 ;
123        I = (m-2):-2:1 ;
124        am = length (I) ;
125
126    elseif (sm == -2)
127
128        % I = 1:2:(m-2)
129        if (m < 5)
130            continue
131        end
132        clear I0
133        I0.begin = 0 ;
134        I0.inc = 2 ;
135        I0.end = m-3 ;
136        I = 1:2:(m-2) ;
137        am = length (I) ;
138
139    elseif (sm == -1)
140
141        % I = 1:(m-2)
142        if (m < 5)
143            continue
144        end
145        clear I0
146        I0.begin = 0 ;
147        I0.end = m-3 ;
148        I = 1:(m-2) ;
149        am = length (I) ;
150
151    elseif (sm == 0)
152
153        % I = ":"
154        I = [ ] ;
155        am = m ;
156        I0 = uint64 (I-1) ;
157
158    else
159
160        % I = random list of length sm
161        I = randperm (m,sm) ;
162        am = sm ;
163        I0 = uint64 (I-1) ;
164
165    end
166
167    if (sn == 0)
168        J = [ ] ;
169        an = n ;
170    else
171        J = randperm (n,sn) ; % J = J(1:sn);
172        an = sn ;
173    end
174    J0 = uint64 (J-1) ;
175
176    for A_is_hyper = 0:1
177    for A_is_csc   = 0:1
178    for C_is_hyper = 0:1
179    for C_is_csc   = 0:1
180    for M_is_hyper = 0:1
181    for M_is_csc   = 0:1
182
183    quick = quick+1 ;
184    if (~fulltest)
185        % only do every 11th test
186        if (mod (quick, 11) ~= 1)
187            continue
188        end
189    end
190
191    if (scalar)
192        % test scalar expansion
193        % fprintf ('test expansion\n') ;
194        A.matrix = sparse (rand (1)) * 100 ;
195        A.pattern = sparse (logical (true));
196        A.class = atype ;
197        if (A_is_hyper || ~A_is_csc)
198            continue
199        end
200    else
201        A = GB_spec_random (am,an,0.2,100,atype, A_is_csc, A_is_hyper) ;
202    end
203
204    C = GB_spec_random (m,n,0.2,100,atype, C_is_csc, C_is_hyper) ;
205    Mask = GB_random_mask (m,n,0.2, M_is_csc, M_is_hyper) ;
206
207    % C(I,J) = accum (C (I,J),A)
208    % Mask = [ ] ;
209    C0 = GB_spec_assign (C, [ ], accum, A, I, J, dn, scalar);
210    C1 = GB_mex_assign  (C, [ ], accum, A, I0, J0, dn);
211    GB_spec_compare (C0, C1) ;
212
213    % C<Mask>(I,J) = accum (C (I,J),A)
214    C0 = GB_spec_assign (C, Mask, accum, A, I, J, dn, scalar);
215    C1 = GB_mex_assign  (C, Mask, accum, A, I0, J0, dn);
216    GB_spec_compare (C0, C1) ;
217
218    %---------------------------------------
219
220    % C<Mask>(I,J) = accum (C(I,J), A');
221    % note transposing twice
222    clear AT
223    AT.matrix  = A.matrix' ;
224    AT.pattern = A.pattern' ;
225    AT.class = A.class ;
226
227    C0 = GB_spec_assign (C, [ ], accum, AT, I, J, dt, scalar);
228    C1 = GB_mex_assign  (C, [ ], accum, AT, I0, J0, dt);
229    GB_spec_compare (C0, C1) ;
230
231    C0 = GB_spec_assign (C, Mask, accum, AT, I, J, dt, scalar);
232    C1 = GB_mex_assign  (C, Mask, accum, AT, I0, J0, dt);
233    GB_spec_compare (C0, C1) ;
234
235    %---------------------------------------
236
237end
238end
239end
240end
241end
242end
243end
244end
245end
246end
247end
248end
249end
250end
251end
252end
253
254fprintf ('\ntest21b: all tests passed\n') ;
255
256
257