refactor: Vector.{VectorFormat}

Author: IgorErin

src/GraphBLAS-sharp.Backend/Objects/Vector.fs

@@ -72,23 +72,24 @@ and ClSparseVector<'a> =
 
     member this.Dispose(q) = (this :> IDeviceMemObject).Dispose(q)
 
+[<RequireQualifiedAccess>]
 type Vector<'a when 'a: struct> =
-    | VectorSparse of SparseVector<'a>
-    | VectorDense of 'a option []
+    | Sparse of SparseVector<'a>
+    | Dense of 'a option []
     member this.Size =
         match this with
-        | VectorSparse vector -> vector.Size
-        | VectorDense vector -> vector.Size
+        | Sparse vector -> vector.Size
+        | Dense vector -> vector.Size
 
     override this.ToString() =
         match this with
-        | VectorSparse vector -> vector.ToString()
-        | VectorDense vector -> DenseVectorToString vector
+        | Sparse vector -> vector.ToString()
+        | Dense vector -> DenseVectorToString vector
 
     member this.ToDevice(context: ClContext) =
         match this with
-        | VectorSparse vector -> ClVectorSparse <| vector.ToDevice(context)
-        | VectorDense vector -> ClVectorDense <| vector.ToDevice(context)
+        | Sparse vector -> ClVectorSparse <| vector.ToDevice(context)
+        | Dense vector -> ClVectorDense <| vector.ToDevice(context)
 
 and ClVector<'a when 'a: struct> =
     | ClVectorSparse of ClSparseVector<'a>
@@ -100,8 +101,8 @@ and ClVector<'a when 'a: struct> =
 
     member this.ToHost(q: MailboxProcessor<_>) =
         match this with
-        | ClVectorSparse vector -> VectorSparse <| vector.ToHost(q)
-        | ClVectorDense vector -> VectorDense <| vector.ToHost(q)
+        | ClVectorSparse vector -> Vector.Sparse <| vector.ToHost(q)
+        | ClVectorDense vector -> Vector.Dense <| vector.ToHost(q)
 
     member this.Dispose(q) =
         match this with

tests/GraphBLAS-sharp.Tests/Algorithms/BFS.fs

@@ -51,7 +51,7 @@ let testFixtures (testContext: TestContext) =
                   res.Dispose queue
 
                   match resHost with
-                  | VectorDense resHost ->
+                  | Vector.Dense resHost ->
                       let actual = resHost |> Utils.unwrapOptionArray 0
 
                       Expect.sequenceEqual actual expected "Sequences must be equal"

tests/GraphBLAS-sharp.Tests/Helpers.fs

@@ -668,10 +668,10 @@ module Utils =
     let createVectorFromArray vectorCase array isZero =
         match vectorCase with
         | VectorFormat.Sparse ->
-            VectorSparse
+            Vector.Sparse
             <| SparseVector.FromArray(array, isZero)
         | VectorFormat.Dense ->
-            VectorDense
+            Vector.Dense
             <| ArraysExtensions.DenseVectorFromArray(array, isZero)
 
     let createArrayFromDictionary size zero (dictionary: System.Collections.Generic.Dictionary<int, 'a>) =

tests/GraphBLAS-sharp.Tests/Vector/Copy.fs

@@ -18,15 +18,15 @@ let checkResult (isEqual: 'a -> 'a -> bool) (actual: Vector<'a>) (expected: Vect
     Expect.equal actual.Size expected.Size "The size should be the same"
 
     match actual, expected with
-    | VectorDense actual, VectorDense expected ->
+    | Vector.Dense actual, Vector.Dense expected ->
         let isEqual left right =
             match left, right with
             | Some left, Some right -> isEqual left right
             | None, None -> true
             | _, _ -> false
 
         compareArrays isEqual actual expected "The values array must contain the default value"
-    | VectorSparse actual, VectorSparse expected ->
+    | Vector.Sparse actual, Vector.Sparse expected ->
         compareArrays isEqual actual.Values expected.Values "The values array must contain the default value"
         compareArrays (=) actual.Indices expected.Indices "The index array must contain the 0"
     | _, _ -> failwith "Copy format must be the same"

tests/GraphBLAS-sharp.Tests/Vector/ElementWiseAtLeasOne.fs

@@ -35,7 +35,7 @@ let checkResult
         expectedArray.[i] <- op leftArray.[i] rightArray.[i]
 
     match actual with
-    | VectorSparse actual ->
+    | Vector.Sparse actual ->
         let actualArray =
             Array.create expectedArrayLength resultZero
 

tests/GraphBLAS-sharp.Tests/Vector/Elementwise.fs

@@ -28,11 +28,11 @@ let checkResult isEqual resultZero (op: 'a -> 'b -> 'c) (actual: Vector<'c>) (le
     for i in 0 .. expectedArrayLength - 1 do
         expectedArray.[i] <- op leftArray.[i] rightArray.[i]
 
-    let (VectorDense expected) =
+    let (Vector.Dense expected) =
         createVectorFromArray Dense expectedArray (isEqual resultZero)
 
     match actual with
-    | VectorDense actual ->
+    | Vector.Dense actual ->
         "arrays must have the same values"
         |> Expect.equal actual expected
     | _ -> failwith "Vector format must be Sparse."

tests/GraphBLAS-sharp.Tests/Vector/FillSubVector.fs

@@ -47,7 +47,7 @@ let checkResult
             expectedArray.[i] <- vector.[i]
 
     match actual with
-    | VectorSparse actual ->
+    | Vector.Sparse actual ->
         let actualArray = Array.create vector.Length vectorZero
 
         for i in 0 .. actual.Indices.Length - 1 do

tests/GraphBLAS-sharp.Tests/Vector/OfList.fs

@@ -23,7 +23,7 @@ let checkResult
     Expect.equal actual.Size actualSize "lengths must be the same"
 
     match actual with
-    | VectorSparse actual ->
+    | Vector.Sparse actual ->
         compareArrays (=) actual.Indices expectedIndices "indices must be the same"
         compareArrays isEqual actual.Values expectedValues "values must be the same"
     | _ -> failwith "Vector format must be Sparse."

tests/GraphBLAS-sharp.Tests/Vector/SpMV.fs

@@ -64,7 +64,7 @@ let correctnessGenericTest
             let m = mtx.ToBackend testContext.ClContext
 
             match vtr, m with
-            | VectorDense vtr, ClMatrix.CSR m ->
+            | Vector.Dense vtr, ClMatrix.CSR m ->
                 let v = vtr.ToDevice testContext.ClContext
 
                 let res = spMV testContext.Queue m v

tests/GraphBLAS-sharp.Tests/Vector/ZeroCreate.fs

@@ -16,11 +16,11 @@ let checkResult size (actual: Vector<'a>) =
     Expect.equal actual.Size size "The size should be the same"
 
     match actual with
-    | VectorDense vector ->
+    | Vector.Dense vector ->
         Array.iter
         <| (fun item -> Expect.equal item None "values must be None")
         <| vector
-    | VectorSparse vector ->
+    | Vector.Sparse vector ->
         Expect.equal vector.Values [| Unchecked.defaultof<'a> |] "The values array must contain the default value"
         Expect.equal vector.Indices [| 0 |] "The index array must contain the 0"