Add storage for dense vector; extended api with unmasked methods

Author: dpanfilyonok

src/GraphBLAS-sharp/AlgebraicStructures.fs

@@ -4,26 +4,21 @@ open Microsoft.FSharp.Quotations
 
 type UnaryOp<'a, 'b> =
     | UnaryOp of Expr<'a -> 'b>
-    static member op_Implicit (UnaryOp source) = source
 
 type BinaryOp<'a, 'b, 'c> =
     | BinaryOp of Expr<'a -> 'b -> 'c>
-    static member op_Implicit (BinaryOp source) = source
 
-// делать отдельными классами или оставить аллиасами
 type ClosedUnaryOp<'a> =
     | ClosedUnaryOp of Expr<'a -> 'a>
-    static member op_Implicit (UnaryOp source) = source
 
 type ClosedBinaryOp<'a> =
     | ClosedBinaryOp of Expr<'a -> 'a -> 'a>
-    static member op_Implicit (UnaryOp source) = source
 
 // associative closed bin op (magma with associative)
 type ISemigroup<'a> =
     abstract Plus: ClosedBinaryOp<'a>
 
-// semigroup with id
+/// Semigroup with identity
 type IMonoid<'a> =
     inherit ISemigroup<'a>
     abstract Zero: 'a

src/GraphBLAS-sharp/Algorithms/BFS.fs

@@ -6,24 +6,24 @@ open GraphBLAS.FSharp
 open Brahma.FSharp.OpenCL.WorkflowBuilder.Basic
 open Brahma.FSharp.OpenCL.WorkflowBuilder.Evaluation
 
-[<AutoOpen>]
 module BFS =
-    let levelBFS (matrix: Matrix<bool>) (source: int) : GraphblasEvaluation<Vector<int>> =
+    let level (matrix: Matrix<bool>) (source: int) = graphblas {
         let vertexCount = Matrix.rowCount matrix
-        let levels = Vector.ofArray <| (=) 0 <| Array.zeroCreate vertexCount
+        let levels = Vector.zeroCreate vertexCount 0
         let frontier = Vector.ofList vertexCount [source, true]
 
-        graphblas {
-            let mutable currentLevel = 1
-            while currentLevel < vertexCount do
-                let! frontierMask = Vector.mask frontier
-                do! Vector.fillSubVector frontierMask (Scalar currentLevel) levels
-                let! levelsComplemented = Vector.complemented levels
-                let! frontier = Vector.vxm AnyAll.bool levelsComplemented frontier matrix
-                currentLevel <- currentLevel + 1
-
-            return levels
-        }
+        let mutable currentLevel = 1
+        while currentLevel < vertexCount do
+            let! frontierMask = Vector.mask frontier
+            do! levels |> Vector.fillSubVector frontierMask (Scalar currentLevel)
+
+            let! levelsComplemented = Vector.complemented levels
+            let! frontier = (frontier, matrix) ||> Vector.vxmWithMask AnyAll.bool levelsComplemented
+
+            currentLevel <- currentLevel + 1
+
+        return levels
+    }
 
     // let parentBFS (matrix: Matrix<bool>) (source: int) : Vector<int> =
     //     let vertexCount = matrix.RowCount

src/GraphBLAS-sharp/Algorithms/SSSP.fs

@@ -0,0 +1,18 @@
+namespace GraphBLAS.FSharp.Algorithms
+
+open GraphBLAS.FSharp.Predefined
+open GraphBLAS.FSharp
+open Brahma.FSharp.OpenCL.WorkflowBuilder.Basic
+open Brahma.FSharp.OpenCL.WorkflowBuilder.Evaluation
+
+module ShortestPath =
+    let singleSource (matrix: Matrix<float>) (source: int) = graphblas {
+        let vertexCount = Matrix.rowCount matrix
+        let distance = Vector.ofList vertexCount [source, 0.]
+
+        for _ = 1 to vertexCount - 1 do
+            let! step = (distance, matrix) ||> Vector.vxm MinAdd.float
+            do! distance |> Vector.assignVector step
+
+        return distance
+    }

src/GraphBLAS-sharp/Algorithms/ShortestPath.fs

@@ -5,18 +5,16 @@ open GraphBLAS.FSharp
 open Brahma.FSharp.OpenCL.WorkflowBuilder.Basic
 open Brahma.FSharp.OpenCL.WorkflowBuilder.Evaluation
 
-[<AutoOpen>]
 module TriangleCounting =
-    let sandiaTriangleCount (lowerTriangular: Matrix<bool>) : GraphblasEvaluation<int> =
+    let sandia (lowerTriangular: Matrix<bool>) = graphblas {
         let bool2int = function
             | true -> 1
             | false -> 0
 
-        graphblas {
-            let! convertedMatrix = lowerTriangular |> Matrix.apply (UnaryOp <@ bool2int @>) None
-            let! convertedTransposed = convertedMatrix |> Matrix.transpose
-            let! lowerTriangularMask = lowerTriangular |> Matrix.mask
-            let! result = Matrix.mxm AddMult.int lowerTriangularMask convertedMatrix convertedTransposed
-            let! (Scalar count) = result |> Matrix.reduce Add.int
-            return count
-        }
+        let! convertedMatrix = lowerTriangular |> Matrix.apply (UnaryOp <@ bool2int @>)
+        let! convertedTransposed = convertedMatrix |> Matrix.transpose
+        let! lowerTriangularMask = lowerTriangular |> Matrix.mask
+        let! result = Matrix.mxmWithMask AddMult.int lowerTriangularMask convertedMatrix convertedTransposed
+        let! (Scalar count) = result |> Matrix.reduce Add.int
+        return count
+    }

src/GraphBLAS-sharp/Algorithms/TriangleCounting.fs

@@ -29,7 +29,7 @@
     <Compile Include="Predefined/Semirings/AddMult.fs" />
     <Compile Include="Predefined/Semirings/MinAdd.fs" />
     <Compile Include="Algorithms/BFS.fs" />
-    <Compile Include="Algorithms/SSSP.fs" />
+    <Compile Include="Algorithms/ShortestPath.fs" />
     <Compile Include="Algorithms/TriangleCounting.fs" />
     <Content Include="YC.OpenCL.NET.dll.config">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>

src/GraphBLAS-sharp/GraphBLAS-sharp.fsproj

@@ -1,7 +1,6 @@
 namespace GraphBLAS.FSharp
 
 open Brahma.FSharp.OpenCL.WorkflowBuilder.Basic
-open Brahma.FSharp.OpenCL.WorkflowBuilder.Evaluation
 open GraphBLAS.FSharp.Backend
 
 type MatrixTuples<'a> =
@@ -56,50 +55,124 @@ module Matrix =
     let resize (rowCount: int) (columnCount: int) (matrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> = failwith "Not Implemented yet"
     let nnz (matrix: Matrix<'a>) : GraphblasEvaluation<int> = failwith "Not Implemented yet"
     let tuples (matrix: Matrix<'a>) : GraphblasEvaluation<MatrixTuples<'a>> = failwith "Not Implemented yet"
-    let mask (matrix: Matrix<'a>) : GraphblasEvaluation<Mask2D option> = failwith "Not Implemented yet"
-    let complemented (matrix: Matrix<'a>) : GraphblasEvaluation<Mask2D option> = failwith "Not Implemented yet"
+    let mask (matrix: Matrix<'a>) : GraphblasEvaluation<Mask2D> = failwith "Not Implemented yet"
+    let complemented (matrix: Matrix<'a>) : GraphblasEvaluation<Mask2D> = failwith "Not Implemented yet"
     let synchronize (matrix: Matrix<'a>) : GraphblasEvaluation<unit> = failwith "Not Implemented yet"
 
     (*
         assignment, extraction and filling
     *)
 
-    let extractSubMatrix (mask: Mask2D option) (matrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> = failwith "Not Implemented yet"
-    let extractSubRow (rowIdx: int) (mask: Mask2D option) (matrix: Matrix<'a>) : GraphblasEvaluation<Vector<'a>> = failwith "Not Implemented yet"
-    let extractSubCol (colIdx: int) (mask: Mask2D option) (matrix: Matrix<'a>) : GraphblasEvaluation<Vector<'a>> = failwith "Not Implemented yet"
-    let extractElement (rowIdx: int) (colIdx: int) (matrix: Matrix<'a>) : GraphblasEvaluation<Scalar<'a>> = failwith "Not Implemented yet"
-    let assignSubMatrix (mask: Mask2D option) (source: Matrix<'a>) (target: Matrix<'a>) : GraphblasEvaluation<unit> = failwith "Not Implemented yet"
-    let assignSubRow (rowIdx: int) (mask: Mask2D option) (source: Vector<'a>) (target: Matrix<'a>) : GraphblasEvaluation<unit> = failwith "Not Implemented yet"
-    let assignSubCol (colIdx: int) (mask: Mask2D option) (source: Vector<'a>) (target: Matrix<'a>) : GraphblasEvaluation<unit> = failwith "Not Implemented yet"
-    let assignElement (rowIdx: int) (colIdx: int) (source: Scalar<'a>) (target: Matrix<'a>) : GraphblasEvaluation<unit> = failwith "Not Implemented yet"
-    let fillSubMatrix (mask: Mask2D option) (filler: Scalar<'a>) (matrix: Matrix<'a>) : GraphblasEvaluation<unit> = failwith "Not Implemented yet"
-    let fillSubRow (rowIdx: int) (mask: Mask2D option) (filler: Scalar<'a>) (matrix: Matrix<'a>) : GraphblasEvaluation<unit> = failwith "Not Implemented yet"
-    let fillSubCol (colIdx: int) (mask: Mask2D option) (filler: Scalar<'a>) (matrix: Matrix<'a>) : GraphblasEvaluation<unit> = failwith "Not Implemented yet"
+    /// mat.[mask]
+    let extractSubMatrix (mask: Mask2D option) (matrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> =
+        failwith "Not Implemented yet"
+
+    /// mat.[rowIdx. *]
+    let extractRow (rowIdx: int) (matrix: Matrix<'a>) : GraphblasEvaluation<Vector<'a>> =
+        failwith "Not Implemented yet"
+
+    /// mat.[rowIdx, mask]
+    let extractSubRow (rowIdx: int) (mask: Mask2D) (matrix: Matrix<'a>) : GraphblasEvaluation<Vector<'a>> =
+        failwith "Not Implemented yet"
+
+    /// mat.[*, colIdx]
+    let extractCol (colIdx: int) (matrix: Matrix<'a>) : GraphblasEvaluation<Vector<'a>> =
+        failwith "Not Implemented yet"
+
+    /// mat.[mask. colIdx]
+    let extractSubCol (colIdx: int) (mask: Mask2D) (matrix: Matrix<'a>) : GraphblasEvaluation<Vector<'a>> =
+        failwith "Not Implemented yet"
+
+    /// mat.[rowIdx, colIdx]
+    let extractValue (rowIdx: int) (colIdx: int) (matrix: Matrix<'a>) : GraphblasEvaluation<Scalar<'a>> =
+        failwith "Not Implemented yet"
+
+    /// t <- s
+    let assignMatrix (source: Matrix<'a>) (target: Matrix<'a>) : GraphblasEvaluation<unit> =
+        failwith "Not Implemented yet"
+
+    /// t.[mask] <- s
+    let assignSubMatrix (mask: Mask2D) (source: Matrix<'a>) (target: Matrix<'a>) : GraphblasEvaluation<unit> =
+        failwith "Not Implemented yet"
+
+    /// t.[rowIdx, *] <- s
+    let assignRow (rowIdx: int) (source: Vector<'a>) (target: Matrix<'a>) : GraphblasEvaluation<unit> =
+        failwith "Not Implemented yet"
+
+    /// t.[rowIdx, mask] <- s
+    let assignSubRow (rowIdx: int) (mask: Mask1D) (source: Vector<'a>) (target: Matrix<'a>) : GraphblasEvaluation<unit> =
+        failwith "Not Implemented yet"
+
+    /// t.[*, colIdx] <- s
+    let assignCol (colIdx: int) (source: Vector<'a>) (target: Matrix<'a>) : GraphblasEvaluation<unit> =
+        failwith "Not Implemented yet"
+
+    /// t.[mask, colIdx] <- s
+    let assignSubCol (colIdx: int) (mask: Mask1D) (source: Vector<'a>) (target: Matrix<'a>) : GraphblasEvaluation<unit> =
+        failwith "Not Implemented yet"
+
+    /// mat.[i, j] <- value
+    let assignValue (rowIdx: int) (colIdx: int) (value: Scalar<'a>) (matrix: Matrix<'a>) : GraphblasEvaluation<unit> =
+        failwith "Not Implemented yet"
+
+    /// mat.[*, *] <- value
+    let fillMatrix (value: Scalar<'a>) (matrix: Matrix<'a>) : GraphblasEvaluation<unit> =
+        failwith "Not Implemented yet"
+
+    /// mat.[mask] <- value
+    let fillSubMatrix (mask: Mask2D) (value: Scalar<'a>) (matrix: Matrix<'a>) : GraphblasEvaluation<unit> =
+        failwith "Not Implemented yet"
+
+    /// mat.[rowIdx, *] <- value
+    let fillRow (rowIdx: int) (value: Scalar<'a>) (matrix: Matrix<'a>) : GraphblasEvaluation<unit> =
+        failwith "Not Implemented yet"
+
+    /// mat.[rowIdx, mask] <- value
+    let fillSubRow (rowIdx: int) (mask: Mask1D) (value: Scalar<'a>) (matrix: Matrix<'a>) : GraphblasEvaluation<unit> =
+        failwith "Not Implemented yet"
+
+    /// mat.[*, colIdx] <- value
+    let fillCol (colIdx: int) (value: Scalar<'a>) (matrix: Matrix<'a>) : GraphblasEvaluation<unit> =
+        failwith "Not Implemented yet"
+
+    /// mat.[mask, colIdx] <- value
+    let fillSubCol (colIdx: int) (mask: Mask1D) (value: Scalar<'a>) (matrix: Matrix<'a>) : GraphblasEvaluation<unit> =
+        failwith "Not Implemented yet"
 
     (*
         operations
     *)
 
-    let mxm (semiring: ISemiring<'a>) (mask: Mask2D option) (leftMatrix: Matrix<'a>) (rightMatrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> = failwith "Not Implemented yet"
-    let mxv (semiring: ISemiring<'a>) (mask: Mask1D option) (matrix: Matrix<'a>) (vector: Vector<'a>) : GraphblasEvaluation<Vector<'a>> = failwith "Not Implemented yet"
+    let mxm (semiring: ISemiring<'a>) (leftMatrix: Matrix<'a>) (rightMatrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> = failwith "Not Implemented yet"
+    let mxv (semiring: ISemiring<'a>) (matrix: Matrix<'a>) (vector: Vector<'a>) : GraphblasEvaluation<Vector<'a>> = failwith "Not Implemented yet"
 
-    let eWiseAdd (semiring: ISemiring<'a>) (mask: Mask2D option) (leftMatrix: Matrix<'a>) (rightMatrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> =
+    let eWiseAdd (semiring: ISemiring<'a>) (leftMatrix: Matrix<'a>) (rightMatrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> =
         let operationResult =
             match leftMatrix, rightMatrix with
             | MatrixCOO left, MatrixCOO right ->
                 opencl {
-                    let! result = COOMatrix.EWiseAdd.run left right mask semiring
+                    let! result = COOMatrix.EWiseAdd.run left right None semiring
                     return MatrixCOO result
                 }
             | _ -> failwith "Not Implemented"
 
         graphblas { return! EvalGB.fromCl operationResult }
 
-    let eWiseMult (semiring: ISemiring<'a>) (mask: Mask2D option) (leftMatrix: Matrix<'a>) (rightMatrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> = failwith "Not Implemented yet"
-    let apply (mapper: UnaryOp<'a, 'b>) (mask: Mask2D option) (matrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'b>> = failwith "Not Implemented yet"
-    let prune (predicate: UnaryOp<'a, bool>) (mask: Mask2D option) (matrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> = failwith "Not Implemented yet"
-    let reduceRows (monoid: IMonoid<'a>) (mask: Mask1D) (matrix: Matrix<'a>) : GraphblasEvaluation<Vector<'a>> = failwith "Not Implemented yet"
-    let reduceCols (monoid: IMonoid<'a>) (mask: Mask1D) (matrix: Matrix<'a>) : GraphblasEvaluation<Vector<'a>> = failwith "Not Implemented yet"
+    let eWiseMult (semiring: ISemiring<'a>) (leftMatrix: Matrix<'a>) (rightMatrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> = failwith "Not Implemented yet"
+    let apply (mapper: UnaryOp<'a, 'b>) (matrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'b>> = failwith "Not Implemented yet"
+    let prune (predicate: UnaryOp<'a, bool>) (matrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> = failwith "Not Implemented yet"
+    let reduceRows (monoid: IMonoid<'a>) (matrix: Matrix<'a>) : GraphblasEvaluation<Vector<'a>> = failwith "Not Implemented yet"
+    let reduceCols (monoid: IMonoid<'a>) (matrix: Matrix<'a>) : GraphblasEvaluation<Vector<'a>> = failwith "Not Implemented yet"
     let reduce (monoid: IMonoid<'a>) (matrix: Matrix<'a>) : GraphblasEvaluation<Scalar<'a>> = failwith "Not Implemented yet"
     let transpose (matrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'b>> = failwith "Not Implemented yet"
-    let kronecker (semiring: ISemiring<'a>) (mask: Mask2D option) (leftMatrix: Matrix<'a>) (rightMatrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> = failwith "Not Implemented yet"
+    let kronecker (semiring: ISemiring<'a>) (leftMatrix: Matrix<'a>) (rightMatrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> = failwith "Not Implemented yet"
+
+    let mxmWithMask (semiring: ISemiring<'a>) (mask: Mask2D) (leftMatrix: Matrix<'a>) (rightMatrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> = failwith "Not Implemented yet"
+    let mxvWithMask (semiring: ISemiring<'a>) (mask: Mask1D) (matrix: Matrix<'a>) (vector: Vector<'a>) : GraphblasEvaluation<Vector<'a>> = failwith "Not Implemented yet"
+    let eWiseAddWithMask (semiring: ISemiring<'a>) (mask: Mask2D) (leftMatrix: Matrix<'a>) (rightMatrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> = failwith "Not Implemented yet"
+    let eWiseMultWithMask (semiring: ISemiring<'a>) (mask: Mask2D) (leftMatrix: Matrix<'a>) (rightMatrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> = failwith "Not Implemented yet"
+    let applyWithMask (mapper: UnaryOp<'a, 'b>) (mask: Mask2D) (matrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'b>> = failwith "Not Implemented yet"
+    let pruneWithMask (predicate: UnaryOp<'a, bool>) (mask: Mask2D) (matrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> = failwith "Not Implemented yet"
+    let reduceRowsWithMask (monoid: IMonoid<'a>) (mask: Mask1D) (matrix: Matrix<'a>) : GraphblasEvaluation<Vector<'a>> = failwith "Not Implemented yet"
+    let reduceColsWithMask (monoid: IMonoid<'a>) (mask: Mask1D) (matrix: Matrix<'a>) : GraphblasEvaluation<Vector<'a>> = failwith "Not Implemented yet"
+    let kroneckerWithMask (semiring: ISemiring<'a>) (mask: Mask2D) (leftMatrix: Matrix<'a>) (rightMatrix: Matrix<'a>) : GraphblasEvaluation<Matrix<'a>> = failwith "Not Implemented yet"