refactor: move Matrix.map, Vector.map; add: Vector.map tests

Author: artemiipatov

src/GraphBLAS-sharp.Backend/Matrix/COO/Map.fs

@@ -11,7 +11,7 @@ open GraphBLAS.FSharp.Objects.ClMatrix
 open GraphBLAS.FSharp.Objects.ClContextExtensions
 
 module internal Map =
-    let preparePositions<'a, 'b> opAdd (clContext: ClContext) workGroupSize =
+    let private preparePositions<'a, 'b> opAdd (clContext: ClContext) workGroupSize =
 
         let preparePositions (op: Expr<'a option -> 'b option>) =
             <@ fun (ndRange: Range1D) rowCount columnCount valuesLength (values: ClArray<'a>) (rows: ClArray<int>) (columns: ClArray<int>) (resultBitmap: ClArray<int>) (resultValues: ClArray<'b>) (resultRows: ClArray<int>) (resultColumns: ClArray<int>) ->

src/GraphBLAS-sharp.Backend/Matrix/COO/Map2.fs

@@ -11,7 +11,7 @@ open GraphBLAS.FSharp.Backend.Matrix
 
 module internal Map2 =
 
-    let preparePositions<'a, 'b, 'c> opAdd (clContext: ClContext) workGroupSize =
+    let private preparePositions<'a, 'b, 'c> opAdd (clContext: ClContext) workGroupSize =
 
         let preparePositions (op: Expr<'a option -> 'b option -> 'c option>) =
             <@ fun (ndRange: Range1D) rowCount columnCount leftValuesLength rightValuesLength (leftValues: ClArray<'a>) (leftRows: ClArray<int>) (leftColumns: ClArray<int>) (rightValues: ClArray<'b>) (rightRows: ClArray<int>) (rightColumn: ClArray<int>) (resultBitmap: ClArray<int>) (resultValues: ClArray<'c>) (resultRows: ClArray<int>) (resultColumns: ClArray<int>) ->
@@ -135,7 +135,7 @@ module internal Map2 =
               Values = resultValues }
 
     module AtLeastOne =
-        let preparePositionsAtLeastOne<'a, 'b, 'c when 'a: struct and 'b: struct and 'c: struct and 'c: equality>
+        let private preparePositionsAtLeastOne<'a, 'b, 'c when 'a: struct and 'b: struct and 'c: struct and 'c: equality>
             (clContext: ClContext)
             (opAdd: Expr<'a option -> 'b option -> 'c option>)
             workGroupSize

src/GraphBLAS-sharp.Backend/Matrix/CSR/Map.fs

@@ -12,7 +12,7 @@ open GraphBLAS.FSharp.Objects.ClContextExtensions
 open GraphBLAS.FSharp.Objects.ArraysExtensions
 
 module internal Map =
-    let preparePositions<'a, 'b> op (clContext: ClContext) workGroupSize =
+    let private preparePositions<'a, 'b> op (clContext: ClContext) workGroupSize =
 
         let preparePositions (op: Expr<'a option -> 'b option>) =
             <@ fun (ndRange: Range1D) rowCount columnCount (values: ClArray<'a>) (rowPointers: ClArray<int>) (columns: ClArray<int>) (resultBitmap: ClArray<int>) (resultValues: ClArray<'b>) (resultRows: ClArray<int>) (resultColumns: ClArray<int>) ->
@@ -115,7 +115,7 @@ module internal Map =
               Values = resultValues }
 
     module WithValue =
-        let preparePositions<'a, 'b, 'c when 'b: struct> (clContext: ClContext) workGroupSize op =
+        let private preparePositions<'a, 'b, 'c when 'b: struct> (clContext: ClContext) workGroupSize op =
 
             let preparePositions (op: Expr<'a option -> 'b option -> 'c option>) =
                 <@ fun (ndRange: Range1D) (operand: ClCell<'a option>) rowCount columnCount (values: ClArray<'b>) (rowPointers: ClArray<int>) (columns: ClArray<int>) (resultBitmap: ClArray<int>) (resultValues: ClArray<'c>) (resultRows: ClArray<int>) (resultColumns: ClArray<int>) ->

src/GraphBLAS-sharp.Backend/Matrix/CSR/Map2.fs

@@ -10,7 +10,7 @@ open GraphBLAS.FSharp.Objects.ClMatrix
 open GraphBLAS.FSharp.Objects.ClContextExtensions
 
 module internal Map2 =
-    let preparePositions<'a, 'b, 'c> opAdd (clContext: ClContext) workGroupSize =
+    let private preparePositions<'a, 'b, 'c> opAdd (clContext: ClContext) workGroupSize =
 
         let preparePositions (op: Expr<'a option -> 'b option -> 'c option>) =
             <@ fun (ndRange: Range1D) rowCount columnCount (leftValues: ClArray<'a>) (leftRowPointers: ClArray<int>) (leftColumns: ClArray<int>) (rightValues: ClArray<'b>) (rightRowPointers: ClArray<int>) (rightColumn: ClArray<int>) (resultBitmap: ClArray<int>) (resultValues: ClArray<'c>) (resultRows: ClArray<int>) (resultColumns: ClArray<int>) ->
@@ -135,7 +135,7 @@ module internal Map2 =
               Values = resultValues }
 
     module AtLeastOne =
-        let preparePositions<'a, 'b, 'c when 'a: struct and 'b: struct and 'c: struct and 'c: equality>
+        let private preparePositions<'a, 'b, 'c when 'a: struct and 'b: struct and 'c: struct and 'c: equality>
             (opAdd: Expr<'a option -> 'b option -> 'c option>)
             (clContext: ClContext)
             workGroupSize

src/GraphBLAS-sharp.Backend/Matrix/Matrix.fs

@@ -266,36 +266,6 @@ module Matrix =
                 |> ClMatrix.LIL
             | ClMatrix.LIL _ -> copy processor allocationMode matrix
 
-    /// <summary>
-    /// Builds a new matrix whose elements are the results of applying the given function
-    /// to each of the elements of the matrix.
-    /// </summary>
-    /// <param name="op">
-    /// A function to transform values of the input matrix.
-    /// Operand and result types should be optional to distinguish explicit and implicit zeroes
-    /// </param>
-    /// <param name="clContext">OpenCL context.</param>
-    /// <param name="workGroupSize">Should be a power of 2 and greater than 1.</param>
-    let map (op: Expr<'a option -> 'b option>) (clContext: ClContext) workGroupSize =
-        let mapCOO =
-            COO.Matrix.map op clContext workGroupSize
-
-        let mapCSR =
-            CSR.Matrix.map op clContext workGroupSize
-
-        let transposeCOO =
-            COO.Matrix.transposeInPlace clContext workGroupSize
-
-        fun (processor: MailboxProcessor<_>) allocationMode matrix ->
-            match matrix with
-            | ClMatrix.COO m -> mapCOO processor allocationMode m |> ClMatrix.COO
-            | ClMatrix.CSR m -> mapCSR processor allocationMode m |> ClMatrix.COO
-            | ClMatrix.CSC m ->
-                (mapCSR processor allocationMode m.ToCSR)
-                |> transposeCOO processor
-                |> ClMatrix.COO
-            | _ -> failwith "Not yet implemented"
-
     /// <summary>
     /// Transposes the given matrix and returns result.
     /// The given matrix should neither be used afterwards nor be disposed.

src/GraphBLAS-sharp.Backend/Operations/Operations.fs

@@ -11,6 +11,32 @@ open GraphBLAS.FSharp.Backend.Operations
 [<RequireQualifiedAccess>]
 module Operations =
     module Vector =
+        /// <summary>
+        /// Builds a new vector whose elements are the results of applying the given function
+        /// to each of the elements of the vector.
+        /// </summary>
+        /// <param name="op">
+        /// A function to transform values of the input vector.
+        /// Operand and result types should be optional to distinguish explicit and implicit zeroes.
+        /// </param>
+        /// <param name="clContext">OpenCL context.</param>
+        /// <param name="workGroupSize">Should be a power of 2 and greater than 1.</param>
+        let map (op: Expr<'a option -> 'b option>) (clContext: ClContext) workGroupSize =
+            let mapSparse =
+                Sparse.Vector.map op clContext workGroupSize
+
+            let mapDense =
+                Dense.Vector.map op clContext workGroupSize
+
+            fun (processor: MailboxProcessor<_>) allocationMode matrix ->
+                match matrix with
+                | ClVector.Sparse v ->
+                    mapSparse processor allocationMode v
+                    |> ClVector.Sparse
+                | ClVector.Dense v ->
+                    mapDense processor allocationMode v
+                    |> ClVector.Dense
+
         /// <summary>
         /// Builds a new vector whose values are the results of applying the given function
         /// to the corresponding pairs of values from the two vectors.
@@ -72,6 +98,36 @@ module Operations =
                 | _ -> failwith "Vector formats are not matching."
 
     module Matrix =
+        /// <summary>
+        /// Builds a new matrix whose elements are the results of applying the given function
+        /// to each of the elements of the matrix.
+        /// </summary>
+        /// <param name="op">
+        /// A function to transform values of the input matrix.
+        /// Operand and result types should be optional to distinguish explicit and implicit zeroes
+        /// </param>
+        /// <param name="clContext">OpenCL context.</param>
+        /// <param name="workGroupSize">Should be a power of 2 and greater than 1.</param>
+        let map (op: Expr<'a option -> 'b option>) (clContext: ClContext) workGroupSize =
+            let mapCOO =
+                COO.Matrix.map op clContext workGroupSize
+
+            let mapCSR =
+                CSR.Matrix.map op clContext workGroupSize
+
+            let transposeCOO =
+                COO.Matrix.transposeInPlace clContext workGroupSize
+
+            fun (processor: MailboxProcessor<_>) allocationMode matrix ->
+                match matrix with
+                | ClMatrix.COO m -> mapCOO processor allocationMode m |> ClMatrix.COO
+                | ClMatrix.CSR m -> mapCSR processor allocationMode m |> ClMatrix.COO
+                | ClMatrix.CSC m ->
+                    (mapCSR processor allocationMode m.ToCSR)
+                    |> transposeCOO processor
+                    |> ClMatrix.COO
+                | _ -> failwith "Not yet implemented"
+
         /// <summary>
         /// Builds a new matrix whose values are the results of applying the given function
         /// to the corresponding pairs of values from the two matrices.

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

@@ -148,32 +148,6 @@ module Vector =
                 ClVector.Dense
                 <| toDense processor allocationMode vector
 
-    /// <summary>
-    /// Builds a new vector whose elements are the results of applying the given function
-    /// to each of the elements of the vector.
-    /// </summary>
-    /// <param name="op">
-    /// A function to transform values of the input vector.
-    /// Operand and result types should be optional to distinguish explicit and implicit zeroes.
-    /// </param>
-    /// <param name="clContext">OpenCL context.</param>
-    /// <param name="workGroupSize">Should be a power of 2 and greater than 1.</param>
-    let map (op: Expr<'a option -> 'b option>) (clContext: ClContext) workGroupSize =
-        let mapSparse =
-            Sparse.Vector.map op clContext workGroupSize
-
-        let mapDense =
-            Dense.Vector.map op clContext workGroupSize
-
-        fun (processor: MailboxProcessor<_>) allocationMode matrix ->
-            match matrix with
-            | ClVector.Sparse v ->
-                mapSparse processor allocationMode v
-                |> ClVector.Sparse
-            | ClVector.Dense v ->
-                mapDense processor allocationMode v
-                |> ClVector.Dense
-
     let private assignByMaskGeneral<'a, 'b when 'a: struct and 'b: struct> op (clContext: ClContext) workGroupSize =
 
         let sparseFillVector =

tests/GraphBLAS-sharp.Tests/Backend/Matrix/Map.fs

@@ -97,7 +97,8 @@ let createTestMap case (zero: 'a) (constant: 'a) binOp isEqual opQ =
     let unaryOp = binOp constant
     let unaryOpQ = opQ zero constant
 
-    let map = Matrix.map unaryOpQ context wgSize
+    let map =
+        Operations.Matrix.map unaryOpQ context wgSize
 
     let toCOO = Matrix.toCOO context wgSize
 

tests/GraphBLAS-sharp.Tests/Backend/Vector/Map.fs

@@ -0,0 +1,148 @@
+module GraphBLAS.FSharp.Tests.Backend.Vector.Map
+
+open Expecto
+open Expecto.Logging
+open Expecto.Logging.Message
+open Microsoft.FSharp.Collections
+open GraphBLAS.FSharp
+open GraphBLAS.FSharp.Backend
+open GraphBLAS.FSharp.Backend.Quotes
+open GraphBLAS.FSharp.Tests
+open GraphBLAS.FSharp.Tests.Backend
+open GraphBLAS.FSharp.Tests.TestCases
+open GraphBLAS.FSharp.Objects
+open GraphBLAS.FSharp.Objects.ClContextExtensions
+open GraphBLAS.FSharp.Objects.ClVectorExtensions
+open Mono.CompilerServices.SymbolWriter
+
+let logger = Log.create "Vector.Map.Tests"
+
+let config = Utils.defaultConfig
+let wgSize = Utils.defaultWorkGroupSize
+
+let getCorrectnessTestName case datatype =
+    $"Correctness on %s{datatype}, %A{case}"
+
+let checkResult isEqual op zero (baseVector: 'a []) (actual: Vector<'b>) =
+
+    let expectedArrayLength = baseVector.Length
+
+    let expectedArray =
+        Array.create expectedArrayLength zero
+
+    for i in 0 .. expectedArrayLength - 1 do
+        expectedArray.[i] <- op baseVector.[i]
+
+    let expected =
+        Utils.createVectorFromArray Dense expectedArray (isEqual zero)
+        |> Utils.vectorToDenseVector
+
+    match actual with
+    | Vector.Dense actual ->
+        "arrays must have the same values"
+        |> Expect.equal actual expected
+    | _ -> failwith "Vector format must be Sparse."
+
+let correctnessGenericTest
+    zero
+    op
+    (addFun: MailboxProcessor<_> -> AllocationFlag -> ClVector<'a> -> ClVector<'a>)
+    (toDense: MailboxProcessor<_> -> AllocationFlag -> ClVector<'a> -> ClVector<'a>)
+    (isEqual: 'a -> 'a -> bool)
+    (case: OperationCase<VectorFormat>)
+    (array: 'a [])
+    =
+
+    let isZero = (isEqual zero)
+
+    let vectorHost =
+        Utils.createVectorFromArray case.Format array isZero
+
+    if vectorHost.NNZ > 0 then
+
+        let context = case.TestContext.ClContext
+        let q = case.TestContext.Queue
+
+        let vector = vectorHost.ToDevice context
+
+        try
+            let res =
+                addFun q HostInterop vector
+
+            vector.Dispose q
+
+            let denseActual = toDense q HostInterop res
+
+            let actual = denseActual.ToHost q
+
+            res.Dispose q
+            denseActual.Dispose q
+
+            checkResult isEqual op zero array actual
+        with
+        | ex when ex.Message = "InvalidBufferSize" -> ()
+        | ex -> raise ex
+
+let createTestMap case (zero: 'a) (constant: 'a) binOp isEqual opQ =
+    let getCorrectnessTestName = getCorrectnessTestName case
+
+    let context = case.TestContext.ClContext
+    let q = case.TestContext.Queue
+
+    let unaryOp = binOp constant
+    let unaryOpQ = opQ zero constant
+
+    let map =
+        Operations.Vector.map unaryOpQ context wgSize
+
+    let toDense = Vector.toDense context wgSize
+
+    case
+    |> correctnessGenericTest zero unaryOp map toDense isEqual
+    |> testPropertyWithConfig config (getCorrectnessTestName $"{typeof<'a>}")
+
+let testFixturesMapNot case =
+    [ let q = case.TestContext.Queue
+      q.Error.Add(fun e -> failwithf "%A" e)
+
+      createTestMap case false true (fun _ -> not) (=) (fun _ _ -> ArithmeticOperations.notOption) ]
+
+let notTests =
+    operationGPUTests "not" testFixturesMapNot
+
+let testFixturesMapAdd case =
+    [ let context = case.TestContext.ClContext
+      let q = case.TestContext.Queue
+      q.Error.Add(fun e -> failwithf "%A" e)
+
+      createTestMap case 0 10 (+) (=) ArithmeticOperations.addLeftConst
+
+      if Utils.isFloat64Available context.ClDevice then
+          createTestMap case 0.0 10.0 (+) Utils.floatIsEqual ArithmeticOperations.addLeftConst
+
+      createTestMap case 0.0f 10.0f (+) Utils.float32IsEqual ArithmeticOperations.addLeftConst
+
+      createTestMap case 0uy 10uy (+) (=) ArithmeticOperations.addLeftConst ]
+
+let addTests =
+    operationGPUTests "add" testFixturesMapAdd
+
+let testFixturesMapMul case =
+    [ let context = case.TestContext.ClContext
+      let q = case.TestContext.Queue
+      q.Error.Add(fun e -> failwithf "%A" e)
+
+      createTestMap case 0 10 (*) (=) ArithmeticOperations.mulLeftConst
+
+      if Utils.isFloat64Available context.ClDevice then
+          createTestMap case 0.0 10.0 (*) Utils.floatIsEqual ArithmeticOperations.mulLeftConst
+
+      createTestMap case 0.0f 10.0f (*) Utils.float32IsEqual ArithmeticOperations.mulLeftConst
+
+      createTestMap case 0uy 10uy (*) (=) ArithmeticOperations.mulLeftConst ]
+
+let mulTests =
+    operationGPUTests "mul" testFixturesMapMul
+
+let allTests =
+    testList "Map" [ addTests; mulTests; notTests ]

tests/GraphBLAS-sharp.Tests/GraphBLAS-sharp.Tests.fsproj

@@ -62,6 +62,7 @@
         <Compile Include="Backend/Vector/SpMV.fs" />
         <Compile Include="Backend/Vector/ZeroCreate.fs" />
         <Compile Include="Backend/Vector/Merge.fs" />
+        <Compile Include="Backend/Vector/Map.fs" />
         <Compile Include="Host/Matrix/FromArray2D.fs" />
         <Compile Include="Host/Matrix/Convert.fs" />
         <Compile Include="Host/IO/MtxReader.fs" />