Fix merge 2

Author: dpanfilyonok

src/GraphBLAS-sharp/Algorithms/BFS.fs

@@ -19,7 +19,7 @@ module BFS =
             let! currentLevelScalar = Scalar.create currentLevel
 
             let! frontierMask = Vector.mask frontier
-            do! Vector.fillSubVector levels frontierMask currentLevelScalar
+            do! Vector.fillSubVector levels frontierMask currentLevelScalar // v[q] = d
 
             let! levelsComplemented = Vector.complemented levels
             do! Matrix.mxvWithMask AnyAll.bool levelsComplemented transposed frontier // q[!v] = (A' ||.&& q)' = q' ||.&& A -- replace + comp

src/GraphBLAS-sharp/Algorithms/TriangleCounting.fs

@@ -10,8 +10,8 @@ module TriangleCounting =
         let! transposed = matrix' |> Matrix.transpose
 
         let! lowerTriangularMask = lowerTriangular |> Matrix.mask
-        let! result = (matrix', transposed) ||> Matrix.mxmWithMask AddMult.int lowerTriangularMask
-        let! count = result |> Matrix.reduce Add.int
-
-        return! Scalar.exportValue count
+        return!
+            Matrix.mxmWithMask AddMult.int lowerTriangularMask matrix' transposed
+            >>= Matrix.reduce Add.int
+            >>= Scalar.exportValue
     }

src/GraphBLAS-sharp/Backend/Common/Replicate.fs

@@ -31,5 +31,6 @@ module internal rec Replicate =
         do! RunCommand replicate <| fun kernelPrepare ->
             let ndRange = _1D(Utils.getDefaultGlobalSize outputArray.Length, Utils.defaultWorkGroupSize)
             kernelPrepare ndRange inputArray outputArray
+
         return outputArray
     }

src/GraphBLAS-sharp/Backend/Common/Sum.fs

@@ -7,7 +7,7 @@ open Microsoft.FSharp.Quotations
 module internal rec Sum =
     let run (inputArray: 'a[]) (plus: Expr<'a -> 'a -> 'a>) (zero: 'a) =
         if inputArray.Length = 0 then
-            opencl { return [|zero|] }
+            opencl { return [| zero |] }
         else
             runNotEmpty inputArray plus zero
 

src/GraphBLAS-sharp/GraphBLAS-sharp.fsproj

@@ -17,10 +17,10 @@
     <Compile Include="Objects/Masks.fs" />
     <Compile Include="Backend/Common/Utils.fs" />
     <Compile Include="Backend/Common/Copy.fs" />
-    <Compile Include="Backend/Common/Replicate.fs" />
     <Compile Include="Backend/Common/Sum.fs" />
     <Compile Include="Backend/Common/PrefixSum.fs" />
     <Compile Include="Backend/Common/BitonicSort.fs" />
+    <Compile Include="Backend/Common/Replicate.fs" />
     <Compile Include="Backend/Common/RemoveDuplicates.fs" />
     <Compile Include="Backend/CSRMatrix/Convert.fs" />
     <Compile Include="Backend/CSRMatrix/GetTuples.fs" />
@@ -63,4 +63,4 @@
     </Content>
   </ItemGroup>
   <Import Project="..\..\.paket\Paket.Restore.targets" />
-</Project>
+</Project>

src/GraphBLAS-sharp/Objects/Vector.fs

@@ -6,6 +6,10 @@ type VectorFormat =
 type Vector<'a when 'a : struct> =
     | VectorCOO of COOVector<'a>
 
+    member this.Size =
+        match this with
+        | VectorCOO vector -> vector.Size
+
 and COOVector<'a> =
     {
         mutable Size: int

src/GraphBLAS-sharp/Operations/Scalar.fs

@@ -21,7 +21,6 @@ module Scalar =
         match scalar with
         | ScalarWrapped scalar -> opencl {
             let! _ = ToHost scalar.Value
-
             return ()
         }
         |> EvalGB.fromCl
@@ -30,13 +29,14 @@ module Scalar =
         assignment and extraction
     *)
 
-    let exportValue (scalar: Scalar<'a>) : GraphblasEvaluation<'a> = graphblas {
-        do! synchronize scalar
+    let exportValue (scalar: Scalar<'a>) : GraphblasEvaluation<'a> =
+        graphblas {
+            do! synchronize scalar
 
-        match scalar with
-        | ScalarWrapped scalar ->
-            return scalar.Value.[0]
-    }
+            match scalar with
+            | ScalarWrapped scalar ->
+                return scalar.Value.[0]
+        }
 
     let assignValue (scalar: Scalar<'a>) (target: Scalar<'a>) : GraphblasEvaluation<unit> =
         failwith "Not Implemented yet"

src/GraphBLAS-sharp/Operations/Vector.fs

@@ -112,22 +112,20 @@ module Vector =
 
     /// t.[mask] <- vec
     let assignSubVector (target: Vector<'a>) (mask: Mask1D) (source: Vector<'a>) : GraphblasEvaluation<unit> =
-        match source, target with
-        | VectorCOO s, VectorCOO t ->
-            if t.Size <> mask.Size then
-                invalidArg "mask" <| sprintf "The size of mask must be %A. Received: %A" t.Size mask.Size
-
-            if t.Size <> s.Size then
-                invalidArg "source" <| sprintf "The size of source vector must be %A. Received: %A" t.Size s.Size
-
-            if mask.IsComplemented then
-                failwith "Not Implemented yet"
-            else
-                opencl {
-                    let! (resultIndices, resultValues) = COOVector.AssignSubVector.run t.Indices t.Values s.Indices s.Values mask.Indices
-                    t.Indices <- resultIndices
-                    t.Values <- resultValues
-                }
+        if target.Size <> mask.Size then
+            invalidArg "mask" <| sprintf "The size of mask must be %A. Received: %A" target.Size mask.Size
+
+        if target.Size <> source.Size then
+            invalidArg "source" <| sprintf "The size of source vector must be %A. Received: %A" target.Size source.Size
+
+        match source, target, mask with
+        | VectorCOO source, VectorCOO target, mask when not mask.IsComplemented ->
+            opencl {
+                let! (resultIndices, resultValues) = COOVector.AssignSubVector.run target.Indices target.Values source.Indices source.Values mask.Indices
+                target.Indices <- resultIndices
+                target.Values <- resultValues
+            }
+        | _ -> failwith "Not Implemented"
         |> EvalGB.fromCl
 
     /// t.[idx] <- value
@@ -140,16 +138,14 @@ module Vector =
 
     /// vec.[mask] <- value
     let fillSubVector (vector: Vector<'a>) (mask: Mask1D) (value: Scalar<'a>) : GraphblasEvaluation<unit> =
-        match vector, value with
-        | VectorCOO vector, ScalarWrapped scalar ->
-            if mask.IsComplemented then
-                failwith "Not Implemented yet"
-            else
-                opencl {
-                    let! (resultIndices, resultValues) = COOVector.FillSubVector.run vector.Indices vector.Values mask.Indices scalar.Value
-                    vector.Indices <- resultIndices
-                    vector.Values <- resultValues
-                }
+        match vector, value, mask with
+        | VectorCOO vector, ScalarWrapped scalar, mask when not mask.IsComplemented ->
+            opencl {
+                let! (resultIndices, resultValues) = COOVector.FillSubVector.run vector.Indices vector.Values mask.Indices scalar.Value
+                vector.Indices <- resultIndices
+                vector.Values <- resultValues
+            }
+        | _ -> failwith "Not Implemented"
         |> EvalGB.fromCl
 
     (*
@@ -162,14 +158,12 @@ module Vector =
     let select (predicate: UnaryOp<'a, bool>) (vector: Vector<'a>) : GraphblasEvaluation<Vector<'a>> = failwith "Not Implemented yet"
 
     let reduce (monoid: IMonoid<'a>) (vector: Vector<'a>) : GraphblasEvaluation<Scalar<'a>> =
+        let (ClosedBinaryOp plus) = monoid.Plus
+
         match vector with
         | VectorCOO vector ->
             opencl {
-                let! result = opencl {
-                    let (ClosedBinaryOp plus) = monoid.Plus
-                    return! Sum.run vector.Values plus monoid.Zero
-                }
-
+                let! result = Sum.run vector.Values plus monoid.Zero
                 return ScalarWrapped { Value = result }
             }
         |> EvalGB.fromCl