Fix all admonitions, except semiring closedness

Author: dpanfilyonok

benchmarks/GraphBLAS-sharp.Benchmarks/Config.fs

@@ -25,7 +25,7 @@ type TEPSColumn() =
                 let (nrows, ncols, nnz) = float matrixInfo.[0], float matrixInfo.[1], float matrixInfo.[2]
                 let (vertices, edges) = if nrows = ncols then (nrows, nnz) else (ncols, nrows)
                 sprintf "%f" (edges / meanTime)
-            | _ -> "file`s format not supported"
+            | another -> sprintf "%s files not supported" another
         member this.GetValue(summary: Summary, benchmarkCase: BenchmarkCase, style: SummaryStyle): string =
             (this :> IColumn).GetValue(summary, benchmarkCase)
         member this.Id: string = "TEPSColumn"

src/GraphBLAS-sharp/Abstracts.fs

@@ -20,16 +20,16 @@ type Matrix<'a when 'a : struct and 'a : equality>(nrow: int, ncol: int) =
 
     abstract Mxm: Matrix<'b> -> Mask2D option -> Semiring<'a, 'b, 'c> -> Matrix<'c>
     abstract Mxv: Vector<'b> -> Mask1D option -> Semiring<'a, 'b, 'c> -> Vector<'c>
-    abstract EWiseAdd: Matrix<'a> -> Mask2D option -> BinaryOp<'a, 'b, 'c> -> Matrix<'a>
-    abstract EWiseMult: Matrix<'a> -> Mask2D option -> BinaryOp<'a, 'b, 'c> -> Matrix<'a>
+    abstract EWiseAdd: Matrix<'b> -> Mask2D option -> Semiring<'a, 'b, 'c> -> Matrix<'c>
+    abstract EWiseMult: Matrix<'b> -> Mask2D option -> Semiring<'a, 'b, 'c> -> Matrix<'c>
     abstract Apply: Mask1D option -> UnaryOp<'a, 'b> -> Matrix<'b>
-    abstract ReduceIn: Mask1D option -> BinaryOp<'a, 'b, 'c> -> Vector<'a>
-    abstract ReduceOut: Mask1D option -> BinaryOp<'a, 'b, 'c> -> Vector<'a>
+    abstract ReduceIn: Mask1D option -> Monoid<'a> -> Vector<'a>
+    abstract ReduceOut: Mask1D option -> Monoid<'a> -> Vector<'a>
     abstract Reduce: Monoid<'a> -> Scalar<'a>
     abstract T: Matrix<'a>
 
-    static member inline (+) (x: Matrix<'a>, y: Matrix<'a>) = x.EWiseAdd y
-    static member inline (*) (x: Matrix<'a>, y: Matrix<'a>) = x.EWiseMult y
+    static member inline (+) (x: Matrix<'a>, y: Matrix<'b>) = x.EWiseAdd y
+    static member inline (*) (x: Matrix<'a>, y: Matrix<'b>) = x.EWiseMult y
     static member inline (@.) (x: Matrix<'a>, y: Matrix<'b>) = x.Mxm y
     static member inline (@.) (x: Matrix<'a>, y: Vector<'b>) = x.Mxv y
 
@@ -48,33 +48,36 @@ and [<AbstractClass>] Vector<'a when 'a : struct and 'a : equality>(length: int)
     abstract Fill: Mask1D option -> Scalar<'a> with set
 
     abstract Vxm: Matrix<'b> -> Mask1D option -> Semiring<'a, 'b, 'c> -> Vector<'c>
-    abstract EWiseAdd: Vector<'a> -> Mask1D option -> BinaryOp<'a, 'b, 'c> -> Vector<'a>
-    abstract EWiseMult: Vector<'a> -> Mask1D option -> BinaryOp<'a, 'b, 'c> -> Vector<'a>
+    abstract EWiseAdd: Vector<'b> -> Mask1D option -> Semiring<'a, 'b, 'c> -> Vector<'c>
+    abstract EWiseMult: Vector<'b> -> Mask1D option -> Semiring<'a, 'b, 'c> -> Vector<'c>
     abstract Apply: Mask1D option -> UnaryOp<'a, 'b> -> Vector<'b>
     abstract Reduce: Monoid<'a> -> Scalar<'a>
 
-    static member inline (+) (x: Vector<'a>, y: Vector<'a>) = x.EWiseAdd y
-    static member inline (*) (x: Vector<'a>, y: Vector<'a>) = x.EWiseMult y
+    static member inline (+) (x: Vector<'a>, y: Vector<'b>) = x.EWiseAdd y
+    static member inline (*) (x: Vector<'a>, y: Vector<'b>) = x.EWiseMult y
     static member inline (@.) (x: Vector<'a>, y: Matrix<'b>) = x.Vxm y
 
 and Mask1D(indices: int[], length: int, isComplemented: bool) =
-    member this.IsComplemented = isComplemented
-
     member this.Indices = indices
     member this.Length = length
+    member this.IsComplemented = isComplemented
 
     member this.Item
         with get (idx: int) : bool =
-            this.Indices |> Array.exists ( ( = ) idx) |> ( <> ) this.IsComplemented
+            this.Indices
+            |> Array.exists ((=) idx)
+            |> (<>) this.IsComplemented
 
 and Mask2D(indices: (int * int)[], rowCount: int, columnCount: int, isComplemented: bool) =
-    member this.IsComplemented = isComplemented
-
     member this.Rows = indices |> Array.unzip |> fst
     member this.Columns = indices |> Array.unzip |> snd
     member this.RowCount = rowCount
     member this.ColumnCount = columnCount
+    member this.IsComplemented = isComplemented
 
     member this.Item
         with get (rowIdx: int, colIdx: int) : bool =
-            Array.zip this.Rows this.Columns |> Array.exists ( ( = ) (rowIdx, colIdx)) |> ( <> ) this.IsComplemented
+            (this.Rows, this.Columns)
+            ||> Array.zip
+            |> Array.exists ((=) (rowIdx, colIdx))
+            |> (<>) this.IsComplemented

src/GraphBLAS-sharp/Algorithms/BFS.fs

@@ -25,12 +25,12 @@ module BFS =
     //     let vertexCount = matrix.RowCount
     //     let parents = SparseVector(vertexCount, [source, -1])
 
-    //     let id = DenseVector(Array.init vertexCount id, IntegerMonoid.plus)
+    //     let id = DenseVector(Array.init vertexCount id, IntegerMonoid.add)
     //     let frontier = SparseVector(vertexCount, [source, source])
 
     //     for _ in 1 .. vertexCount - 1 do
-    //         frontier.[Mask1D.complemented parents] <- (frontier .@ matrix) (Mask1D.complemented parents) IntegerSemiring.minFirst
-    //         parents.[Mask1D.regular frontier] <- frontier
-    //         frontier.[Mask1D.regular frontier] <- id
+    //         frontier.[parents.Complemented] <- (frontier @. matrix) parents.Complemented IntegerSemiring.minFirst
+    //         parents.[frontier.Mask] <- frontier
+    //         frontier.[frontier.Mask] <- id
 
     //     upcast parents

src/GraphBLAS-sharp/Algorithms/SSSP.fs

@@ -10,6 +10,6 @@ module SSSP =
         let distance = SparseVector(vertexCount, [source, 0.])
 
         for _ in 1 .. vertexCount - 1 do
-            distance.[None] <- (distance @. matrix) None FloatSemiring.addMult
+            distance.[None] <- (distance @. matrix) None FloatSemiring.minAdd
 
         upcast distance

src/GraphBLAS-sharp/Algorithms/TriangleCounting.fs

@@ -5,8 +5,10 @@ open GraphBLAS.FSharp
 
 [<AutoOpen>]
 module TriangleCounting =
-    // нужна проекция в инт
-    // let sandiaTriangleCount (lowerTriangular: Matrix<bool>) =
-    //     let c = (lowerTriangular .@ lowerTriangular.T) (Mask2D.regular lowerTriangular) BooleanSemiring.anyAll
-    //     c.Reduce BooleanMonoid.any
-    ()
+    let sandiaTriangleCount (lowerTriangular: Matrix<bool>) =
+        let bool2int = function
+            | true -> 1
+            | false -> 0
+        let convertedMatrix = lowerTriangular.Apply None (UnaryOp <@ bool2int @>)
+        let result = (convertedMatrix @. convertedMatrix.T) lowerTriangular.Mask IntegerSemiring.addMult
+        result.Reduce IntegerMonoid.add

src/GraphBLAS-sharp/Predefined/Integer.fs

@@ -14,6 +14,11 @@ module IntegerMonoid =
     }
 
 module IntegerSemiring =
+    let addMult: Semiring<int> = {
+        PlusMonoid = IntegerMonoid.add
+        Times = BinaryOp <@ ( * ) @>
+    }
+
     let minFirst<'b> : Semiring<int, 'b, int> = {
         PlusMonoid = IntegerMonoid.min
         Times = BinaryOp <@ fun x y -> x @>