Skip to content

Commit 5dc4c22

Browse files
abhinavmehndirattaabhinavmehndiratta
committed
add documentation for element wise multiplication
1 parent c973faf commit 5dc4c22

File tree

1 file changed

+302
-1
lines changed

1 file changed

+302
-1
lines changed

‎src/Operations/Element_wise_multiplication.jl

Lines changed: 302 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,15 @@
1+
"""
2+
GrB_eWiseMult(C, mask, accum, op, A, B, desc)
3+
4+
Generic method for element-wise matrix and vector operations: using set intersection.
5+
6+
GrB_eWiseMult computes C<Mask> = accum (C, A.*B), where pairs of elements in two matrices (or vectors) are
7+
pairwise "multiplied" with C(i,j) = mult (A(i,j),B(i,j)). The "multiplication" operator can be any binary operator.
8+
The pattern of the result T=A.*B is the set intersection (not union) of A and B. Entries outside of the intersection
9+
are not computed. This is primary difference with GrB_eWiseAdd. The input matrices A and/or B may be transposed first,
10+
via the descriptor. For a semiring, the mult operator is the semiring's multiply operator; this differs from the
11+
eWiseAdd methods which use the semiring's add operator instead.
12+
"""
113
function GrB_eWiseMult(C::T, mask::V, accum::W, op::U, A::T, B::T,
214
desc::X) where {T <: Union{GrB_Vector, GrB_Matrix}, U <: Union{GrB_BinaryOp, GrB_Monoid, GrB_Semiring},
315
V <: Union{GrB_Vector, GrB_Matrix, GrB_NULL_Type}, W <: valid_accum_types, X <: valid_desc_types}
@@ -17,6 +29,54 @@ function GrB_eWiseMult(C::T, mask::V, accum::W, op::U, A::T, B::T,
1729
)
1830
end
1931

32+
"""
33+
GrB_eWiseMult_Vector_Semiring(w, mask, accum, semiring, u, v, desc)
34+
35+
Compute element-wise vector multiplication using semiring. Semiring's multiply operator is used.
36+
w<mask> = accum (w, u.*v)
37+
38+
# Examples
39+
```jldoctest
40+
julia> using SuiteSparseGraphBLAS
41+
42+
julia> GrB_init(GrB_NONBLOCKING)
43+
GrB_SUCCESS::GrB_Info = 0
44+
45+
julia> u = GrB_Vector{Int64}()
46+
GrB_Vector{Int64}
47+
48+
julia> GrB_Vector_new(u, GrB_INT64, 5)
49+
GrB_SUCCESS::GrB_Info = 0
50+
51+
julia> I1 = [0, 2, 4]; X1 = [10, 20, 3]; n1 = 3;
52+
53+
julia> GrB_Vector_build(u, I1, X1, n1, GrB_FIRST_INT64)
54+
GrB_SUCCESS::GrB_Info = 0
55+
56+
julia> v = GrB_Vector{Float64}()
57+
GrB_Vector{Float64}
58+
59+
julia> GrB_Vector_new(v, GrB_FP64, 5)
60+
GrB_SUCCESS::GrB_Info = 0
61+
62+
julia> I2 = [0, 1, 4]; X2 = [1.1, 2.2, 3.3]; n2 = 3;
63+
64+
julia> GrB_Vector_build(v, I2, X2, n2, GrB_FIRST_FP64)
65+
GrB_SUCCESS::GrB_Info = 0
66+
67+
julia> w = GrB_Vector{Float64}()
68+
GrB_Vector{Float64}
69+
70+
julia> GrB_Vector_new(w, GrB_FP64, 5)
71+
GrB_SUCCESS::GrB_Info = 0
72+
73+
julia> GrB_eWiseMult_Vector_Semiring(w, GrB_NULL, GrB_NULL, GxB_PLUS_TIMES_FP64, u, v, GrB_NULL)
74+
GrB_SUCCESS::GrB_Info = 0
75+
76+
julia> GrB_Vector_extractTuples(w)
77+
([0, 4], [11.0, 9.9])
78+
```
79+
"""
2080
function GrB_eWiseMult_Vector_Semiring( # w<Mask> = accum (w, u.*v)
2181
w::GrB_Vector, # input/output vector for results
2282
mask::T, # optional mask for w, unused if NULL
@@ -37,6 +97,54 @@ function GrB_eWiseMult_Vector_Semiring( # w<Mask> = accum (w, u.*v)
3797
)
3898
end
3999

100+
"""
101+
GrB_eWiseMult_Vector_Monoid(w, mask, accum, monoid, u, v, desc)
102+
103+
Compute element-wise vector multiplication using monoid.
104+
w<mask> = accum (w, u.*v)
105+
106+
# Examples
107+
```jldoctest
108+
julia> using SuiteSparseGraphBLAS
109+
110+
julia> GrB_init(GrB_NONBLOCKING)
111+
GrB_SUCCESS::GrB_Info = 0
112+
113+
julia> u = GrB_Vector{Int64}()
114+
GrB_Vector{Int64}
115+
116+
julia> GrB_Vector_new(u, GrB_INT64, 5)
117+
GrB_SUCCESS::GrB_Info = 0
118+
119+
julia> I1 = [0, 2, 4]; X1 = [10, 20, 3]; n1 = 3;
120+
121+
julia> GrB_Vector_build(u, I1, X1, n1, GrB_FIRST_INT64)
122+
GrB_SUCCESS::GrB_Info = 0
123+
124+
julia> v = GrB_Vector{Float64}()
125+
GrB_Vector{Float64}
126+
127+
julia> GrB_Vector_new(v, GrB_FP64, 5)
128+
GrB_SUCCESS::GrB_Info = 0
129+
130+
julia> I2 = [0, 1, 4]; X2 = [1.1, 2.2, 3.3]; n2 = 3;
131+
132+
julia> GrB_Vector_build(v, I2, X2, n2, GrB_FIRST_FP64)
133+
GrB_SUCCESS::GrB_Info = 0
134+
135+
julia> w = GrB_Vector{Float64}()
136+
GrB_Vector{Float64}
137+
138+
julia> GrB_Vector_new(w, GrB_FP64, 5)
139+
GrB_SUCCESS::GrB_Info = 0
140+
141+
julia> GrB_eWiseMult_Vector_Monoid(w, GrB_NULL, GrB_NULL, GxB_MAX_FP64_MONOID, u, v, GrB_NULL)
142+
GrB_SUCCESS::GrB_Info = 0
143+
144+
julia> GrB_Vector_extractTuples(w)
145+
([0, 4], [10.0, 3.3])
146+
```
147+
"""
40148
function GrB_eWiseMult_Vector_Monoid( # w<Mask> = accum (w, u.*v)
41149
w::GrB_Vector, # input/output vector for results
42150
mask::T, # optional mask for w, unused if NULL
@@ -52,11 +160,59 @@ function GrB_eWiseMult_Vector_Monoid( # w<Mask> = accum (w, u.*v)
52160
dlsym(graphblas_lib, "GrB_eWiseMult_Vector_Monoid"),
53161
Cint,
54162
(Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}, Ptr{Cvoid}),
55-
w.p, mask.p, accum.p, monoic.p, u.p, v.p, desc.p
163+
w.p, mask.p, accum.p, monoid.p, u.p, v.p, desc.p
56164
)
57165
)
58166
end
59167

168+
"""
169+
GrB_eWiseMult_Vector_BinaryOp(w, mask, accum, mult, u, v, desc)
170+
171+
Compute element-wise vector multiplication using binary operator.
172+
w<mask> = accum (w, u.*v)
173+
174+
# Examples
175+
```jldoctest
176+
julia> using SuiteSparseGraphBLAS
177+
178+
julia> GrB_init(GrB_NONBLOCKING)
179+
GrB_SUCCESS::GrB_Info = 0
180+
181+
julia> u = GrB_Vector{Int64}()
182+
GrB_Vector{Int64}
183+
184+
julia> GrB_Vector_new(u, GrB_INT64, 5)
185+
GrB_SUCCESS::GrB_Info = 0
186+
187+
julia> I1 = [0, 2, 4]; X1 = [10, 20, 30]; n1 = 3;
188+
189+
julia> GrB_Vector_build(u, I1, X1, n1, GrB_FIRST_INT64)
190+
GrB_SUCCESS::GrB_Info = 0
191+
192+
julia> v = GrB_Vector{Float64}()
193+
GrB_Vector{Float64}
194+
195+
julia> GrB_Vector_new(v, GrB_FP64, 5)
196+
GrB_SUCCESS::GrB_Info = 0
197+
198+
julia> I2 = [0, 1, 4]; X2 = [1.1, 2.2, 3.3]; n2 = 3;
199+
200+
julia> GrB_Vector_build(v, I2, X2, n2, GrB_FIRST_FP64)
201+
GrB_SUCCESS::GrB_Info = 0
202+
203+
julia> w = GrB_Vector{Float64}()
204+
GrB_Vector{Float64}
205+
206+
julia> GrB_Vector_new(w, GrB_FP64, 5)
207+
GrB_SUCCESS::GrB_Info = 0
208+
209+
julia> GrB_eWiseMult_Vector_BinaryOp(w, GrB_NULL, GrB_NULL, GrB_TIMES_FP64, u, v, GrB_NULL)
210+
GrB_SUCCESS::GrB_Info = 0
211+
212+
julia> GrB_Vector_extractTuples(w)
213+
([0, 4], [11.0, 99.0])
214+
```
215+
"""
60216
function GrB_eWiseMult_Vector_BinaryOp( # w<Mask> = accum (w, u.*v)
61217
w::GrB_Vector, # input/output vector for results
62218
mask::T, # optional mask for w, unused if NULL
@@ -77,6 +233,54 @@ function GrB_eWiseMult_Vector_BinaryOp( # w<Mask> = accum (w, u.*v)
77233
)
78234
end
79235

236+
"""
237+
GrB_eWiseMult_Matrix_Semiring(C, Mask, accum, semiring, A, B, desc)
238+
239+
Compute element-wise matrix multiplication using semiring. Semiring's multiply operator is used.
240+
C<Mask> = accum (C, A.*B)
241+
242+
# Examples
243+
```jldoctest
244+
julia> using SuiteSparseGraphBLAS
245+
246+
julia> GrB_init(GrB_NONBLOCKING)
247+
GrB_SUCCESS::GrB_Info = 0
248+
249+
julia> A = GrB_Matrix{Int64}()
250+
GrB_Matrix{Int64}
251+
252+
julia> GrB_Matrix_new(A, GrB_INT64, 4, 4)
253+
GrB_SUCCESS::GrB_Info = 0
254+
255+
julia> I1 = [0, 0, 2, 2]; J1 = [1, 2, 0, 2]; X1 = [10, 20, 30, 40]; n1 = 4;
256+
257+
julia> GrB_Matrix_build(A, I1, J1, X1, n1, GrB_FIRST_INT64)
258+
GrB_SUCCESS::GrB_Info = 0
259+
260+
julia> B = GrB_Matrix{Int64}()
261+
GrB_Matrix{Int64}
262+
263+
julia> GrB_Matrix_new(B, GrB_INT64, 4, 4)
264+
GrB_SUCCESS::GrB_Info = 0
265+
266+
julia> I2 = [0, 0, 2]; J2 = [3, 2, 0]; X2 = [15, 16, 17]; n2 = 3;
267+
268+
julia> GrB_Matrix_build(B, I2, J2, X2, n2, GrB_FIRST_INT64)
269+
GrB_SUCCESS::GrB_Info = 0
270+
271+
julia> C = GrB_Matrix{Int64}()
272+
GrB_Matrix{Int64}
273+
274+
julia> GrB_Matrix_new(C, GrB_INT64, 4, 4)
275+
GrB_SUCCESS::GrB_Info = 0
276+
277+
julia> GrB_eWiseMult_Matrix_Semiring(C, GrB_NULL, GrB_NULL, GxB_PLUS_TIMES_INT64, A, B, GrB_NULL)
278+
GrB_SUCCESS::GrB_Info = 0
279+
280+
julia> GrB_Matrix_extractTuples(C)
281+
([0, 2], [2, 0], [320, 510])
282+
```
283+
"""
80284
function GrB_eWiseMult_Matrix_Semiring( # C<Mask> = accum (C, A.*B)
81285
C::GrB_Matrix, # input/output matrix for results
82286
Mask::T, # optional mask for C, unused if NULL
@@ -97,6 +301,55 @@ function GrB_eWiseMult_Matrix_Semiring( # C<Mask> = accum (C, A.*B)
97301
)
98302
end
99303

304+
"""
305+
GrB_eWiseMult_Matrix_Monoid(C, Mask, accum, monoid, A, B, desc)
306+
307+
Compute element-wise matrix multiplication using monoid.
308+
C<Mask> = accum (C, A.*B)
309+
310+
# Examples
311+
```jldoctest
312+
julia> using SuiteSparseGraphBLAS
313+
314+
julia> GrB_init(GrB_NONBLOCKING)
315+
GrB_SUCCESS::GrB_Info = 0
316+
317+
julia> A = GrB_Matrix{Int64}()
318+
GrB_Matrix{Int64}
319+
320+
julia> GrB_Matrix_new(A, GrB_INT64, 4, 4)
321+
GrB_SUCCESS::GrB_Info = 0
322+
323+
julia> I1 = [0, 0, 2, 2]; J1 = [1, 2, 0, 2]; X1 = [10, 20, 30, 40]; n1 = 4;
324+
325+
julia> GrB_Matrix_build(A, I1, J1, X1, n1, GrB_FIRST_INT64)
326+
GrB_SUCCESS::GrB_Info = 0
327+
328+
julia> B = GrB_Matrix{Int64}()
329+
GrB_Matrix{Int64}
330+
331+
julia> GrB_Matrix_new(B, GrB_INT64, 4, 4)
332+
GrB_SUCCESS::GrB_Info = 0
333+
334+
julia> I2 = [0, 0, 2]; J2 = [3, 2, 0]; X2 = [15, 16, 17]; n2 = 3;
335+
336+
julia> GrB_Matrix_build(B, I2, J2, X2, n2, GrB_FIRST_INT64)
337+
GrB_SUCCESS::GrB_Info = 0
338+
339+
julia> C = GrB_Matrix{Int64}()
340+
GrB_Matrix{Int64}
341+
342+
julia> GrB_Matrix_new(C, GrB_INT64, 4, 4)
343+
GrB_SUCCESS::GrB_Info = 0
344+
345+
julia> GrB_eWiseMult_Matrix_Monoid(C, GrB_NULL, GrB_NULL, GxB_PLUS_INT64_MONOID, A, B, GrB_NULL)
346+
GrB_SUCCESS::GrB_Info = 0
347+
348+
julia> GrB_Matrix_extractTuples(C)
349+
([0, 2], [2, 0], [36, 47])
350+
```
351+
"""
352+
100353
function GrB_eWiseMult_Matrix_Monoid( # C<Mask> = accum (C, A.*B)
101354
C::GrB_Matrix, # input/output matrix for results
102355
Mask::T, # optional mask for C, unused if NULL
@@ -117,6 +370,54 @@ function GrB_eWiseMult_Matrix_Monoid( # C<Mask> = accum (C, A.*B)
117370
)
118371
end
119372

373+
"""
374+
GrB_eWiseMult_Matrix_BinaryOp(C, Mask, accum, mult, A, B, desc)
375+
376+
Compute element-wise matrix multiplication using binary operator.
377+
C<Mask> = accum (C, A.*B)
378+
379+
# Examples
380+
```jldoctest
381+
julia> using SuiteSparseGraphBLAS
382+
383+
julia> GrB_init(GrB_NONBLOCKING)
384+
GrB_SUCCESS::GrB_Info = 0
385+
386+
julia> A = GrB_Matrix{Int64}()
387+
GrB_Matrix{Int64}
388+
389+
julia> GrB_Matrix_new(A, GrB_INT64, 4, 4)
390+
GrB_SUCCESS::GrB_Info = 0
391+
392+
julia> I1 = [0, 0, 2, 2]; J1 = [1, 2, 0, 2]; X1 = [10, 20, 30, 40]; n1 = 4;
393+
394+
julia> GrB_Matrix_build(A, I1, J1, X1, n1, GrB_FIRST_INT64)
395+
GrB_SUCCESS::GrB_Info = 0
396+
397+
julia> B = GrB_Matrix{Int64}()
398+
GrB_Matrix{Int64}
399+
400+
julia> GrB_Matrix_new(B, GrB_INT64, 4, 4)
401+
GrB_SUCCESS::GrB_Info = 0
402+
403+
julia> I2 = [0, 0, 2]; J2 = [3, 2, 0]; X2 = [15, 16, 17]; n2 = 3;
404+
405+
julia> GrB_Matrix_build(B, I2, J2, X2, n2, GrB_FIRST_INT64)
406+
GrB_SUCCESS::GrB_Info = 0
407+
408+
julia> C = GrB_Matrix{Int64}()
409+
GrB_Matrix{Int64}
410+
411+
julia> GrB_Matrix_new(C, GrB_INT64, 4, 4)
412+
GrB_SUCCESS::GrB_Info = 0
413+
414+
julia> GrB_eWiseMult_Matrix_BinaryOp(C, GrB_NULL, GrB_NULL, GrB_PLUS_INT64, A, B, GrB_NULL)
415+
GrB_SUCCESS::GrB_Info = 0
416+
417+
julia> GrB_Matrix_extractTuples(C)
418+
([0, 2], [2, 0], [36, 47])
419+
```
420+
"""
120421
function GrB_eWiseMult_Matrix_BinaryOp( # C<Mask> = accum (C, A.*B)
121422
C::GrB_Matrix, # input/output matrix for results
122423
Mask::T, # optional mask for C, unused if NULL

0 commit comments

Comments
 (0)