fix documentation

Author: abhinavmehndiratta

src/Operations/Element_wise_addition.jl

@@ -3,13 +3,13 @@
 
 Generic method for element-wise matrix and vector operations: using set union.
 
-GrB_eWiseAdd computes C<Mask> = accum (C, A+B), where pairs of elements in two matrices (or two vectors)
+`GrB_eWiseAdd` computes `C<Mask> = accum (C, A + B)`, where pairs of elements in two matrices (or two vectors)
 are pairwise "added". The "add" operator can be any binary operator. With the plus operator,
-this is the same matrix addition in conventional linear algebra. The pattern of the result T=A+B is
-the set union of A and B. Entries outside of the union are not computed. That is, if both A(i,j) and B(i,j)
-are present in the pattern of A and B, then T(i,j) = A(i,j) "+" B(i,j). If only A(i,j) is present
-then T(i,j) = A (i,j) and the "+" operator is not used. Likewise, if only B(i,j) is in the pattern of B
-but A(i,j) is not in the pattern of A, then T(i,j) = B(i,j). For a semiring, the mult operator is the
+this is the same matrix addition in conventional linear algebra. The pattern of the result T = A + B is
+the set union of A and B. Entries outside of the union are not computed. That is, if both A(i, j) and B(i, j)
+are present in the pattern of A and B, then T(i, j) = A(i, j) "+" B(i, j). If only A(i, j) is present
+then T(i, j) = A (i, j) and the "+" operator is not used. Likewise, if only B(i, j) is in the pattern of B
+but A(i, j) is not in the pattern of A, then T(i, j) = B(i, j). For a semiring, the mult operator is the
 semiring's add operator.
 """
 function GrB_eWiseAdd(C::T, mask::V, accum::W, op::U, A::T, B::T,
@@ -35,7 +35,7 @@ end
     GrB_eWiseAdd_Vector_Semiring(w, mask, accum, semiring, u, v, desc)
 
 Compute element-wise vector addition using semiring. Semiring's add operator is used.
-w<mask> = accum (w, u+v)
+`w<mask> = accum (w, u + v)`
 
 # Examples
 ```jldoctest
@@ -103,7 +103,7 @@ end
     GrB_eWiseAdd_Vector_Monoid(w, mask, accum, monoid, u, v, desc)
 
 Compute element-wise vector addition using monoid.
-w<mask> = accum (w, u+v)
+`w<mask> = accum (w, u + v)`
 
 # Examples
 ```jldoctest
@@ -171,7 +171,7 @@ end
     GrB_eWiseAdd_Vector_BinaryOp(w, mask, accum, add, u, v, desc)
 
 Compute element-wise vector addition using binary operator.
-w<mask> = accum (w, u+v)
+`w<mask> = accum (w, u + v)`
 
 # Examples
 ```jldoctest
@@ -239,7 +239,7 @@ end
     GrB_eWiseAdd_Matrix_Semiring(C, Mask, accum, semiring, A, B, desc)
 
 Compute element-wise matrix addition using semiring. Semiring's add operator is used.
-C<Mask> = accum (C, A+B)
+`C<Mask> = accum (C, A + B)`
 
 # Examples
 ```jldoctest
@@ -316,7 +316,7 @@ end
     GrB_eWiseAdd_Matrix_Monoid(C, Mask, accum, monoid, A, B, desc)
 
 Compute element-wise matrix addition using monoid.
-C<Mask> = accum (C, A+B)
+`C<Mask> = accum (C, A + B)`
 
 # Examples
 ```jldoctest
@@ -384,7 +384,7 @@ end
     GrB_eWiseAdd_Matrix_BinaryOp(C, Mask, accum, add, A, B, desc)
 
 Compute element-wise matrix addition using binary operator.
-C<Mask> = accum (C, A+B)
+`C<Mask> = accum (C, A + B)`
 
 # Examples
 ```jldoctest

src/Operations/Element_wise_multiplication.jl

@@ -3,10 +3,10 @@
 
 Generic method for element-wise matrix and vector operations: using set intersection.
 
-GrB_eWiseMult computes C<Mask> = accum (C, A.*B), where pairs of elements in two matrices (or vectors) are
-pairwise "multiplied" with C(i,j) = mult (A(i,j),B(i,j)). The "multiplication" operator can be any binary operator.
-The pattern of the result T=A.*B is the set intersection (not union) of A and B. Entries outside of the intersection 
-are not computed. This is primary difference with GrB_eWiseAdd. The input matrices A and/or B may be transposed first, 
+`GrB_eWiseMult` computes `C<Mask> = accum (C, A .* B)`, where pairs of elements in two matrices (or vectors) are
+pairwise "multiplied" with C(i, j) = mult (A(i, j), B(i, j)). The "multiplication" operator can be any binary operator.
+The pattern of the result T = A .* B is the set intersection (not union) of A and B. Entries outside of the intersection 
+are not computed. This is primary difference with `GrB_eWiseAdd`. The input matrices A and/or B may be transposed first, 
 via the descriptor. For a semiring, the mult operator is the semiring's multiply operator; this differs from the 
 eWiseAdd methods which use the semiring's add operator instead.
 """
@@ -33,7 +33,7 @@ end
     GrB_eWiseMult_Vector_Semiring(w, mask, accum, semiring, u, v, desc)
 
 Compute element-wise vector multiplication using semiring. Semiring's multiply operator is used.
-w<mask> = accum (w, u.*v)
+`w<mask> = accum (w, u .* v)`
 
 # Examples
 ```jldoctest
@@ -101,7 +101,7 @@ end
     GrB_eWiseMult_Vector_Monoid(w, mask, accum, monoid, u, v, desc)
 
 Compute element-wise vector multiplication using monoid.
-w<mask> = accum (w, u.*v)
+`w<mask> = accum (w, u .* v)`
 
 # Examples
 ```jldoctest
@@ -169,7 +169,7 @@ end
     GrB_eWiseMult_Vector_BinaryOp(w, mask, accum, mult, u, v, desc)
 
 Compute element-wise vector multiplication using binary operator.
-w<mask> = accum (w, u.*v)
+`w<mask> = accum (w, u .* v)`
 
 # Examples
 ```jldoctest
@@ -237,7 +237,7 @@ end
     GrB_eWiseMult_Matrix_Semiring(C, Mask, accum, semiring, A, B, desc)
 
 Compute element-wise matrix multiplication using semiring. Semiring's multiply operator is used.
-C<Mask> = accum (C, A.*B)
+`C<Mask> = accum (C, A .* B)`
 
 # Examples
 ```jldoctest
@@ -305,7 +305,7 @@ end
     GrB_eWiseMult_Matrix_Monoid(C, Mask, accum, monoid, A, B, desc)
 
 Compute element-wise matrix multiplication using monoid.
-C<Mask> = accum (C, A.*B)
+`C<Mask> = accum (C, A .* B)`
 
 # Examples
 ```jldoctest
@@ -374,7 +374,7 @@ end
     GrB_eWiseMult_Matrix_BinaryOp(C, Mask, accum, mult, A, B, desc)
 
 Compute element-wise matrix multiplication using binary operator.
-C<Mask> = accum (C, A.*B)
+`C<Mask> = accum (C, A .* B)`
 
 # Examples
 ```jldoctest