1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
function test160
%TEST160 test GrB_mxm
% SuiteSparse:GraphBLAS, Timothy A. Davis, (c) 2017-2022, All Rights Reserved.
% SPDX-License-Identifier: Apache-2.0
rng ('default') ;
n = 100 ;
Mask.matrix = (rand (n) > 0.5) ;
Mask.pattern = true (n) ;
mtypes = { 'int8', 'int16', 'int32', 'int64', 'double complex' } ;
Mask2 = GB_spec_random (n, n, 1, 0.01, 'logical') ;
Mask2.matrix = logical (Mask2.matrix) ;
Mask2.matrix (:,1) = false ;
Mask2.pattern (:,1) = false ;
semiring.add = 'plus' ;
semiring.multiply = 'times' ;
semiring.class = 'double' ;
dnn = struct ;
dnn_struct = struct ('mask', 'structural') ;
dnn_notM_struct = struct ('mask', 'structural complement') ;
dnn_notM = struct ('mask', 'complement') ;
dnn_notM_hash = struct ('mask', 'complement', 'axb', 'hash') ;
dnn_hash = struct ('axb', 'hash') ;
d = 0.01 ;
A = GB_spec_random (n, n, d, 1, 'double') ;
G = A ;
G.matrix (:,1:2) = 1 ;
G.pattern (:,1:2) = true ;
B = GB_spec_random (n, n, d, 1, 'double') ;
B.matrix (1:2,1) = 1 ;
B.pattern (1:2,1) = true ;
b = GB_spec_random (n, 1, d, 1, 'double') ;
Cin = sparse (n, n) ;
cin = sparse (n, 1) ;
mask.matrix = (rand (n,1) > 0.5) ;
mask.pattern = true (n,1) ;
H.matrix = sparse (ones (n,n)) ;
H.matrix (1,1) = 0 ;
H.pattern = sparse (true (n,n)) ;
H.matrix (1,1) = false ;
H.sparsity = 2 ;
mask2.matrix = sparse (false (n,1)) ;
mask2.matrix (1,1) = true ;
mask2.pattern = sparse (false (n,1)) ;
mask2.pattern (1,1) = true ;
x = GB_spec_random (n, 1, 0.5, 1, 'double') ;
x.sparsity = 2 ;
y = GB_spec_random (n, 1, 0.02, 1, 'double') ;
y.sparsity = 2 ;
K = GB_spec_random (1000, 2, 0.1, 1, 'double') ;
K.matrix (1:2, 1:2) = pi ;
K.pattern (1:2, 1:2) = true ;
K.sparsity = 2 ;
z.matrix = rand (2,1) ;
maskz.matrix = sparse (false (1000,1)) ;
maskz.matrix (1,1) = true ;
maskz.pattern = sparse (false (1000,1)) ;
maskz.pattern (1,1) = true ;
maskz.class = 'logical' ;
cinz = sparse (1000, 1) ;
for k = 1:length (mtypes)
fprintf ('%s ', mtypes {k}) ;
Mask.class = mtypes {k} ;
Mask2.class = mtypes {k} ;
mask.class = mtypes {k} ;
% C<M> = A*B
C1 = GB_spec_mxm (Cin, Mask, [ ], semiring, A, B, dnn) ;
C2 = GB_mex_mxm (Cin, Mask, [ ], semiring, A, B, dnn) ;
GB_spec_compare (C1, C2) ;
% C<M,struct> = A*B
C1 = GB_spec_mxm (Cin, Mask, [ ], semiring, A, B, dnn_struct) ;
C2 = GB_mex_mxm (Cin, Mask, [ ], semiring, A, B, dnn_struct) ;
GB_spec_compare (C1, C2) ;
% C<!M,struct> = A*B
C1 = GB_spec_mxm (Cin, Mask, [ ], semiring, A, B, dnn_notM_struct) ;
C2 = GB_mex_mxm (Cin, Mask, [ ], semiring, A, B, dnn_notM_struct) ;
GB_spec_compare (C1, C2) ;
% C<!M> = A*B
C1 = GB_spec_mxm (Cin, Mask, [ ], semiring, A, B, dnn_notM) ;
C2 = GB_mex_mxm (Cin, Mask, [ ], semiring, A, B, dnn_notM) ;
GB_spec_compare (C1, C2) ;
% C<M> = G*b
C1 = GB_spec_mxm (cin, mask, [ ], semiring, G, b, dnn) ;
C2 = GB_mex_mxm (cin, mask, [ ], semiring, G, b, dnn) ;
GB_spec_compare (C1, C2) ;
% C<!M> = G*b
C1 = GB_spec_mxm (cin, mask, [ ], semiring, G, b, dnn_notM) ;
C2 = GB_mex_mxm (cin, mask, [ ], semiring, G, b, dnn_notM) ;
GB_spec_compare (C1, C2) ;
% C<!M,struct> = A*B
C1 = GB_spec_mxm (cin, mask, [ ], semiring, G, b, dnn_notM_struct) ;
C2 = GB_mex_mxm (cin, mask, [ ], semiring, G, b, dnn_notM_struct) ;
GB_spec_compare (C1, C2) ;
% C<!M> = A*B
C1 = GB_spec_mxm (Cin, Mask2, [ ], semiring, A, B, dnn_notM) ;
C2 = GB_mex_mxm (Cin, Mask2, [ ], semiring, A, B, dnn_notM) ;
GB_spec_compare (C1, C2) ;
% C<!Mask2> = G*B
C1 = GB_spec_mxm (Cin, Mask2, [ ], semiring, G, B, dnn_notM) ;
C2 = GB_mex_mxm (Cin, Mask2, [ ], semiring, G, B, dnn_notM) ;
GB_spec_compare (C1, C2) ;
% C<!M> = H*x
C1 = GB_spec_mxm (cin, mask2, [ ], semiring, H, x, dnn_notM) ;
C2 = GB_mex_mxm (cin, mask2, [ ], semiring, H, x, dnn_notM) ;
GB_spec_compare (C1, C2) ;
% C<!M> = G*x
C1 = GB_spec_mxm (cin, mask2, [ ], semiring, G, x, dnn_notM_hash) ;
C2 = GB_mex_mxm (cin, mask2, [ ], semiring, G, x, dnn_notM_hash) ;
GB_spec_compare (C1, C2) ;
% C<!M> = K*z
z.sparsity = 4 ;
C1 = GB_spec_mxm (cinz, maskz, [ ], semiring, K, z, dnn_notM_hash) ;
C2 = GB_mex_mxm (cinz, maskz, [ ], semiring, K, z, dnn_notM_hash) ;
GB_spec_compare (C1, C2) ;
end
% C = K*z
z.sparsity = 2 ;
C1 = GB_spec_mxm (cinz, [ ], [ ], semiring, K, z, dnn_hash) ;
C2 = GB_mex_mxm (cinz, [ ], [ ], semiring, K, z, dnn_hash) ;
C3 = GB_mex_mxm_generic (cinz, [ ], [ ], semiring, K, z, dnn_hash) ;
GB_spec_compare (C1, C2) ;
GB_spec_compare (C1, C3) ;
% C<!M> = K*z
z.sparsity = 2 ;
C1 = GB_spec_mxm (cinz, maskz, [ ], semiring, K, z, dnn_notM_hash) ;
C2 = GB_mex_mxm (cinz, maskz, [ ], semiring, K, z, dnn_notM_hash) ;
C3 = GB_mex_mxm_generic (cinz, maskz, [ ], semiring, K, z, dnn_notM_hash) ;
GB_spec_compare (C1, C2) ;
GB_spec_compare (C1, C3) ;
fprintf ('\ntest160: all tests passed\n') ;
|
