Fix some algorithms, add one test case

dpanfilyonok · dpanfilyonok · commit c3f8f551065f · 2020-12-07T18:50:41.000+03:00
diff --git a/global.json b/global.json
@@ -1,5 +1,6 @@
 {
     "sdk": {
-        "version": "3.1.302-2"
+        "version": "3.1.302",
+        "rollForward": "latestFeature"
     }
 }
diff --git a/paket.dependencies b/paket.dependencies
@@ -6,6 +6,7 @@ nuget FSharp.Core 4.3.4
 nuget Microsoft.SourceLink.GitHub prerelease copy_local: true
 nuget Microsoft.NETFramework.ReferenceAssemblies copy_local: true
 nuget Expecto 8.13.1
+nuget Expecto.FsCheck 8.13.1
 nuget YoloDev.Expecto.TestSdk 0.8.0
 nuget Microsoft.NET.Test.Sdk 15.7.2
 nuget altcover ~> 6
diff --git a/paket.lock b/paket.lock
@@ -68,10 +68,15 @@ NUGET
     Expecto (8.13.1)
       FSharp.Core (>= 4.3.4) - restriction: || (>= net461) (>= netstandard2.0)
       Mono.Cecil (>= 0.11) - restriction: || (>= net461) (>= netstandard2.0)
+    Expecto.FsCheck (8.13.1)
+      Expecto (>= 8.13.1) - restriction: || (>= net461) (>= netstandard2.0)
+      FsCheck (>= 2.14) - restriction: || (>= net461) (>= netstandard2.0)
     ExtraConstraints.Fody (1.14)
       Fody (>= 6.0) - restriction: || (>= net452) (>= netstandard1.4)
       NETStandard.Library (>= 1.6.1) - restriction: && (< net452) (>= netstandard1.4)
     Fody (6.3) - restriction: || (>= net452) (>= netstandard1.4)
+    FsCheck (2.14.3) - restriction: || (>= net461) (>= netstandard2.0)
+      FSharp.Core (>= 4.2.3) - restriction: || (>= net452) (>= netstandard1.6)
     FSharp.Core (4.3.4)
       System.Collections (>= 4.0.11) - restriction: && (< net45) (>= netstandard1.6) (< netstandard2.0)
       System.Console (>= 4.0) - restriction: && (< net45) (>= netstandard1.6) (< netstandard2.0)
diff --git a/src/GraphBLAS-sharp/Algorithms/BFS.fs b/src/GraphBLAS-sharp/Algorithms/BFS.fs
@@ -9,26 +9,28 @@ module BFS =
     let levelBFS (matrix: Matrix<bool>) (source: int) : Vector<int> =
         let vertexCount = matrix.RowCount
         let levels = DenseVector(Array.zeroCreate vertexCount, IntegerMonoid.plus)
+
         let frontier = SparseVector(vertexCount, [source, true])
 
         let mutable currentLevel = 1
-        while !> (frontier.Reduce BooleanMonoid.any) && currentLevel <= vertexCount do
+        while !> (frontier.Reduce BooleanMonoid.any) && currentLevel < vertexCount do
             levels.Fill(Mask1D.regular frontier) <- Scalar currentLevel
             frontier.Clear()
             frontier.[Mask1D.complemented levels] <- (frontier .@ matrix) (Mask1D.complemented levels) BooleanSemiring.anyAll
             currentLevel <- currentLevel + 1
 
         upcast levels
 
-    let parentBFS (matrix: Matrix<bool>) (source: int) : Vector<int> =
-        let vertexCount = matrix.RowCount
-        let id = DenseVector(Array.init vertexCount id, IntegerMonoid.plus)
-        let frontier = SparseVector(vertexCount, [source, source])
-        let parents = SparseVector(vertexCount, [source, -1])
+    // let parentBFS (matrix: Matrix<bool>) (source: int) : Vector<int> =
+    //     let vertexCount = matrix.RowCount
+    //     let parents = SparseVector(vertexCount, [source, -1])
+
+    //     let id = DenseVector(Array.init vertexCount id, IntegerMonoid.plus)
+    //     let frontier = SparseVector(vertexCount, [source, source])
 
-        for i in 0 .. vertexCount - 1 do
-            frontier.[Mask1D.complemented parents] <- (frontier .@ matrix) (Mask1D.complemented parents) IntegerSemiring.minFirst
-            parents.[Mask1D.regular frontier] <- frontier
-            frontier.[Mask1D.regular frontier] <- id
+    //     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
 
-        upcast parents
+    //     upcast parents
diff --git a/src/GraphBLAS-sharp/Algorithms/SSSP.fs b/src/GraphBLAS-sharp/Algorithms/SSSP.fs
@@ -8,7 +8,8 @@ module SSSP =
     let SSSP (matrix: Matrix<float>) (source: int) : Vector<float> =
         let vertexCount = matrix.RowCount
         let distance = SparseVector(vertexCount, [source, 0.])
-        for i in 0 .. vertexCount - 1 do
+
+        for _ in 1 .. vertexCount - 1 do
             distance.[Mask1D.none] <- (distance .@ matrix) Mask1D.none FloatSemiring.minPlus
 
         upcast distance
diff --git a/src/GraphBLAS-sharp/Algorithms/TriangleCounting.fs b/src/GraphBLAS-sharp/Algorithms/TriangleCounting.fs
@@ -5,6 +5,8 @@ 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 c = (lowerTriangular .@ lowerTriangular.T) (Mask2D.regular lowerTriangular) BooleanSemiring.anyAll
+    //     c.Reduce BooleanMonoid.any
+    ()
diff --git a/src/GraphBLAS-sharp/Backend.fs b/src/GraphBLAS-sharp/Backend.fs
@@ -0,0 +1,9 @@
+namespace GraphBLAS.FSharp
+
+module Backend =
+    type Matrix<'a when 'a : struct and 'a : equality> with
+        static member Build(matrix: 'b[,], matrixType: MatrixBackendFormat) : Matrix<'b> = failwith "Not Implemented"
+        static member ZeroCreate(rowCount: int, columnCount: int, matrixType: MatrixBackendFormat) : Matrix<'b> = failwith "Not Implemented"
+
+    // type Vector<'a when 'a : struct and 'a : equality> with
+    //     static member ZeroCreate
diff --git a/src/GraphBLAS-sharp/GraphBLAS-sharp.fsproj b/src/GraphBLAS-sharp/GraphBLAS-sharp.fsproj
@@ -16,6 +16,7 @@
     <Compile Include="Scalar.fs" />
     <Compile Include="Abstracts.fs" />
     <Compile Include="Implementations.fs" />
+    <Compile Include="Backend.fs" />
     <Compile Include="Matrix.fs" />
     <Compile Include="Vector.fs" />
     <Compile Include="Masks.fs" />
diff --git a/src/GraphBLAS-sharp/Matrix.fs b/src/GraphBLAS-sharp/Matrix.fs
@@ -1,7 +1,12 @@
 namespace GraphBLAS.FSharp
 
+open Backend
+
 [<AutoOpen>]
 [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
 module Matrix =
     type Matrix<'a when 'a : struct and 'a : equality> with
-        static member Build (filename: string) : Matrix<'b> = failwith "Not Implemented"
+        static member Build(matrix: 'b[,]) : Matrix<'b> = Matrix.Build(matrix, matrixBackendFormat)
+        static member Build(filename: string) : Matrix<'b> = failwith "Not Implemented"
+        static member ZeroCreate(rowCount: int, columnCount: int) : Matrix<'b> = Matrix.ZeroCreate(rowCount, columnCount)
+
diff --git a/src/GraphBLAS-sharp/Predefined/Float.fs b/src/GraphBLAS-sharp/Predefined/Float.fs
@@ -3,12 +3,22 @@ namespace GraphBLAS.FSharp.Predefined
 open GraphBLAS.FSharp
 
 module FloatMonoid =
+    let plus: Monoid<float> = {
+        Zero = 0.
+        Append = BinaryOp <@ ( + ) @>
+    }
+
     let min: Monoid<float> = {
         Zero = System.Double.PositiveInfinity
         Append = BinaryOp <@ fun x y -> System.Math.Min(x, y) @>
     }
 
 module FloatSemiring =
+    let plusTimes: Semiring<float> = {
+        PlusMonoid = FloatMonoid.plus
+        Times = BinaryOp <@ ( * ) @>
+    }
+
     let minPlus: Semiring<float> = {
         PlusMonoid = FloatMonoid.min
         Times = BinaryOp <@ ( + ) @>
diff --git a/src/GraphBLAS-sharp/Vector.fs b/src/GraphBLAS-sharp/Vector.fs
@@ -1,5 +1,7 @@
 namespace GraphBLAS.FSharp
 
+open Backend
+
 [<AutoOpen>]
 [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
 module Vector =
diff --git a/tests/GraphBLAS-sharp.Tests/Common.fs b/tests/GraphBLAS-sharp.Tests/Common.fs
@@ -0,0 +1,35 @@
+namespace GraphBLAS.FSharp.Tests
+
+open System
+
+type VectorType =
+    | Sparse = 0
+    | Dense = 1
+
+type MatrixType =
+    | CSR = 0
+    | COO = 1
+    | Dense = 2
+
+type MaskType =
+    | Regular = 0
+    | Complemented = 1
+    | None = 2
+
+module Utils =
+    let rec cartesian lstlst =
+        match lstlst with
+        | [x] ->
+            List.fold (fun acc elem -> [elem]::acc) [] x
+        | h::t ->
+            List.fold (fun cacc celem ->
+                (List.fold (fun acc elem -> (elem::celem)::acc) [] h) @ cacc
+                ) [] (cartesian t)
+        | _ -> []
+
+    /// Return all values for an enumeration type
+    let enumValues (enumType: Type) : int list =
+        let values = Enum.GetValues enumType
+        let lb = values.GetLowerBound 0
+        let ub = values.GetUpperBound 0
+        [lb .. ub] |> List.map (fun i -> values.GetValue i :?> int)
diff --git a/tests/GraphBLAS-sharp.Tests/GraphBLAS-sharp.Tests.fsproj b/tests/GraphBLAS-sharp.Tests/GraphBLAS-sharp.Tests.fsproj
@@ -8,8 +8,9 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="AssemblyInfo.fs" />
+    <Compile Include="Common.fs" />
     <Compile Include="OperationsTests/VxmTests.fs" />
     <Compile Include="Main.fs" />
   </ItemGroup>
   <Import Project="..\..\.paket\Paket.Restore.targets" />
-</Project>
+</Project>
diff --git a/tests/GraphBLAS-sharp.Tests/OperationsTests/VxmTests.fs b/tests/GraphBLAS-sharp.Tests/OperationsTests/VxmTests.fs
@@ -1,79 +1,104 @@
 namespace GraphBLAS.FSharp.Tests
 
 open Expecto
+open FsCheck
 open System
+open GraphBLAS.FSharp
 
-type VectorType =
-    | Sparse = 0
-    | Dense = 1
+type OperationCase = {
+    VectorCase: VectorType
+    MatrixCase: MatrixType
+    MaskCase: MaskType
+}
 
-type MatrixType =
-    | CSR = 0
-    | COO = 1
-    | Dense = 2
+type MatrixMultiplicationPair =
+    static member DimensionGen2 () =
+        fun size ->
+            Gen.choose (0, size |> float |> sqrt |> int)
+            |> Gen.two
+        |> Gen.sized
+        |> Arb.fromGen
 
-type MaskType =
-    | Regular = 0
-    | Complemented = 1
-    | None = 2
+    static member DimensionGen3 () =
+        fun size ->
+            Gen.choose (0, size |> float |> sqrt |> int)
+            |> Gen.three
+        |> Gen.sized
+        |> Arb.fromGen
 
-type OperationCase = {
-    VectorCaseType: VectorType
-    MatrixCaseType: MatrixType
-    MaskCaseType: MaskType
-}
+    static member FloatSparseMatrixVectorPair () =
+        fun size ->
+            let floatSparseGenerator =
+                Gen.oneof [
+                    Arb.Default.NormalFloat () |> Arb.toGen |> Gen.map float
+                    Gen.constant 0.
+                ]
+
+            let dimGenerator =
+                Gen.choose (0, size |> float |> sqrt |> int)
+                |> Gen.two
+
+            gen {
+                let! (rows, cols) = dimGenerator
+                let! matrix = floatSparseGenerator |> Gen.array2DOfDim (rows, cols)
+                let! vector = floatSparseGenerator |> Gen.arrayOfLength cols
+                return (matrix, vector)
+            }
+            |> Gen.filter (fun (matrix, vector) -> matrix.Length <> 0 && vector.Length <> 0)
+            |> Gen.filter (fun (matrix, vector) ->
+                matrix |> Seq.cast<float> |> Seq.exists (fun elem -> abs elem > System.Double.Epsilon) &&
+                vector |> Seq.cast<float> |> Seq.exists (fun elem -> abs elem > System.Double.Epsilon))
+        |> Gen.sized
+        |> Arb.fromGen
 
 module VxmTests =
-    let rec cartesian lstlst =
-        match lstlst with
-        | [x] ->
-            List.fold (fun acc elem -> [elem]::acc) [] x
-        | h::t ->
-            List.fold (fun cacc celem ->
-                (List.fold (fun acc elem -> (elem::celem)::acc) [] h) @ cacc
-                ) [] (cartesian t)
-        | _ -> []
+    open Backend
 
-    /// Return all values for an enumeration type
-    let enumValues (enumType: Type) : int list =
-        let values = Enum.GetValues enumType
-        let lb = values.GetLowerBound 0
-        let ub = values.GetUpperBound 0
-        [lb .. ub] |> List.map (fun i -> values.GetValue i :?> int)
+    let config = { FsCheckConfig.defaultConfig with arbitrary = [typeof<MatrixMultiplicationPair>] }
 
     let testCases =
         [
             typeof<VectorType>
             typeof<MatrixType>
             typeof<MaskType>
         ]
-        |> List.map enumValues
-        |> cartesian
-        |> List.map (fun list -> {
-                VectorCaseType = enum<VectorType> list.[0]
-                MatrixCaseType = enum<MatrixType> list.[1]
-                MaskCaseType = enum<MaskType> list.[2]
+        |> List.map Utils.enumValues
+        |> Utils.cartesian
+        |> List.map (fun list ->
+            {
+                VectorCase = enum<VectorType> list.[0]
+                MatrixCase = enum<MatrixType> list.[1]
+                MaskCase = enum<MaskType> list.[2]
             })
 
-    let matrix =
-        array2D [ [ 12; 0; 7 ]
-                  [ 1; 0; 0 ]
-                  [ 3; 6; 9 ] ]
+    [<Tests>]
+    let vxmTestList =
+        testList "Vector-matrix multiplication tests" (
+            List.collect (fun case ->
+                let matrixBackend =
+                    match case.MatrixCase with
+                    | MatrixType.CSR -> CSR
+                    | _ -> failwith "Not Implemented"
+                // let vectorConstructor =
+                //     match case.VectorCase with
+                //     | VectorType.Sparse ->
 
-    let vector = [| 1; 1; 0 |]
+                [
+                    testPropertyWithConfig config "Dimensional mismatch should raise an exception" <|
+                        // тут просто размерности генерить и создавать пустые объекты
+                        fun m n k ->
+                            let emptyMatrix = Matrix.ZeroCreate(m, n, matrixBackend)
+                            let emptyVector = Vector.Dense(Predefined.FloatMonoid.plus)
 
-    [<Tests>]
-    let testList =
-        testList "aaa" (
-            testCases
-            |> List.collect (fun case ->
-                    let a = 1 // определеям контекст
-                    testParam case [
-                        "2", fun value () -> Expect.equal a a "ss"
-                    ] |> List.ofSeq
-                )
-        )
+                            Expect.throwsT
+                                (fun () -> (emptyVector .@ emptyMatrix) Mask1D.none Predefined.FloatSemiring.plusTimes |> ignore)
+                                (sprintf "Argument has invalid dimension. Need %i, but given %i" k m )
 
-// member this.Baddimensions() = ()
-// let corectness = ()
-// let zerovalue = ()
+                    testPropertyWithConfig config "Operation should have correct semantic" <|
+                        fun (matrix: float[,]) (vector: float[,]) -> ()
+
+                    ptestPropertyWithConfig config "Explicit zeroes after operation should be dropped" <|
+                        fun a b -> a + b = b + a
+                ]
+            ) testCases
+        )
diff --git a/tests/GraphBLAS-sharp.Tests/paket.references b/tests/GraphBLAS-sharp.Tests/paket.references
@@ -2,6 +2,7 @@ FSharp.Core
 Microsoft.NETFramework.ReferenceAssemblies
 
 Expecto
+Expecto.FsCheck
 Microsoft.NET.Test.Sdk
 YoloDev.Expecto.TestSdk
 

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"sdk": {`
`3`		`- "version": "3.1.302-2"`
	`3`	`+ "version": "3.1.302",`
	`4`	`+ "rollForward": "latestFeature"`
`4`	`5`	`}`
`5`	`6`	`}`