Update interface with OpenCLEvaluation. Disable fody

Author: dpanfilyonok

Directory.Build.props

@@ -9,5 +9,6 @@
         <Authors>YaccConstructor</Authors>
         <RepositoryUrl>https://github.com/YaccConstructor/GraphBLAS-sharp</RepositoryUrl>
         <!-- owners is not supported in MSBuild -->
+        <DisableFody>true</DisableFody>
     </PropertyGroup>
 </Project>

src/GraphBLAS-sharp/Abstracts.fs

@@ -2,81 +2,114 @@ namespace GraphBLAS.FSharp
 
 open Brahma.FSharp.OpenCL.WorkflowBuilder.Evaluation
 
+(*
+    везде вместо того, чтобы возвращать unit, можно возвращать измененный объект,
+    но нужно подумать, насколько создание нового объекта лучше/хуже изменения существующего
+    копирование большмх матриц явно хуже и зачем, а вот Clear сделать не inplace мб имеет смысл
+
+    везде методы, тк проперти не соответсвуют концепции отсутствия вычислений,
+    хотя выглядеть будет оч плохо
+
+    можно все операции, в которых не меняется структура объекта, сделать inplace
+    (хотя, если операция затрагивает весь объект, то все равно читать и писать,
+     единственно, что памяти единовременно в 2 раза больше потребуется)
+
+    теперь есть единственный метод GetMask (без GetComplemented)
+    тк это теперь не свойство, то требует аргумента, а значит можно передавать isComplemented
+
+    методы Extract и Assign, которые возвращают/присваивают подграф, семантически отличаются от тех, что в C
+    здесь возвращаемый подграф (подматрица) всегда того же размера, что и изначальная матрица
+    (т.е в матрице смежности вершины графа не удалаются, а только ребра)
+    поэтому перед операцией нужно сравнивать размерности матрицы и маски, по которой мы получаем подграф
+    чтобы удалить еще и вершины, можно потом сделать resize
+
+    у вектора размерность теперь называется size, а не length, потому что идейно вектор -- набор вершин
+    + в C API тоже size
+
+    метод Prune можно переименовать в Select или Filter
+
+    нужно выяснить, как Partitial Aplication методы интеропятся с C#
+
+    возможно, стоит отказаться от перегрузок Extract и Assign, чтобы сделать их PA,
+    тем самым, избавившись от скобок при вызове
+
+    можно все методы сделать как методы C# (без PA), а рядом положить модуль с PA функциями
+    это нужно, для более гибкого интерфейся и лучшего интеропа с C#
+*)
+
 [<AbstractClass>]
 type Matrix<'a when 'a : struct and 'a : equality>(nrow: int, ncol: int) =
     abstract RowCount: int
     abstract ColumnCount: int
     default this.RowCount = nrow
     default this.ColumnCount = ncol
 
-    abstract Extract: Mask2D option -> Matrix<'a>
-    abstract Extract: (Mask1D option * int) -> Vector<'a>
-    abstract Extract: (int * Mask1D option) -> Vector<'a>
-    abstract Extract: (int * int) -> Scalar<'a>
-    // Размерности должны совпадать
-    abstract Assign: Mask2D option * Matrix<'a> -> unit
-    abstract Assign: (Mask1D option * int) * Vector<'a> -> unit
-    abstract Assign: (int * Mask1D option) * Vector<'a> -> unit
-    abstract Assign: (int * int) * Scalar<'a> -> unit
-    abstract Assign: Mask2D option * Scalar<'a> -> unit
-    abstract Assign: (Mask1D option * int) * Scalar<'a> -> unit
-    abstract Assign: (int * Mask1D option) * Scalar<'a> -> unit
-    // abstract Resize
-    // abstract Dup
-    // abstract Clear
-    // abstract NNZ
-    // abstract Tuples: OpenCLEvaluation<{| Rows: int[]; Columns: int[]; Values: 'a[] |}>
-
-    abstract Mxm: Matrix<'a> -> Mask2D option -> Semiring<'a> -> Matrix<'a>
-    abstract Mxv: Vector<'a> -> Mask1D option -> Semiring<'a> -> Vector<'a>
-    abstract EWiseAdd: Matrix<'a> -> Mask2D option -> Monoid<'a> -> Matrix<'a>
-    abstract EWiseMult: Matrix<'a> -> Mask2D option -> Monoid<'a> -> Matrix<'a>
-    abstract Apply: Mask2D option -> UnaryOp<'a, 'b> -> Matrix<'b>
-    abstract Prune: Mask2D option -> UnaryOp<'a, bool> -> Matrix<'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>
-    // abstract Kronecker
-
-    abstract Mask: Mask2D option
-    abstract Complemented: Mask2D option
+    abstract Clear: unit -> OpenCLEvaluation<unit>
+    abstract Copy: unit -> OpenCLEvaluation<Matrix<'a>>
+    abstract Resize: int -> int -> OpenCLEvaluation<Matrix<'a>>
+    abstract GetNNZ: unit -> OpenCLEvaluation<int>
+    abstract GetTuples: unit -> OpenCLEvaluation<{| Rows: int[]; Columns: int[]; Values: 'a[] |}>
+    abstract GetMask: bool -> OpenCLEvaluation<Mask2D option>
+
+    abstract Extract: Mask2D option -> OpenCLEvaluation<Matrix<'a>>
+    abstract Extract: (Mask1D option * int) -> OpenCLEvaluation<Vector<'a>>
+    abstract Extract: (int * Mask1D option) -> OpenCLEvaluation<Vector<'a>>
+    abstract Extract: (int * int) -> OpenCLEvaluation<Scalar<'a>>
+    abstract Assign: Mask2D option * Matrix<'a> -> OpenCLEvaluation<unit>
+    abstract Assign: (Mask1D option * int) * Vector<'a> -> OpenCLEvaluation<unit>
+    abstract Assign: (int * Mask1D option) * Vector<'a> -> OpenCLEvaluation<unit>
+    abstract Assign: (int * int) * Scalar<'a> -> OpenCLEvaluation<unit>
+    abstract Assign: Mask2D option * Scalar<'a> -> OpenCLEvaluation<unit>
+    abstract Assign: (Mask1D option * int) * Scalar<'a> -> OpenCLEvaluation<unit>
+    abstract Assign: (int * Mask1D option) * Scalar<'a> -> OpenCLEvaluation<unit>
+
+    abstract Mxm: Matrix<'a> -> Mask2D option -> Semiring<'a> -> OpenCLEvaluation<Matrix<'a>>
+    abstract Mxv: Vector<'a> -> Mask1D option -> Semiring<'a> -> OpenCLEvaluation<Vector<'a>>
+    abstract EWiseAdd: Matrix<'a> -> Mask2D option -> Semiring<'a> -> OpenCLEvaluation<Matrix<'a>>
+    abstract EWiseMult: Matrix<'a> -> Mask2D option -> Semiring<'a> -> OpenCLEvaluation<Matrix<'a>>
+    abstract Apply: Mask2D option -> UnaryOp<'a, 'b> -> OpenCLEvaluation<Matrix<'b>>
+    abstract Prune: Mask2D option -> UnaryOp<'a, bool> -> OpenCLEvaluation<Matrix<'a>>
+    abstract ReduceIn: Mask1D option -> Monoid<'a> -> OpenCLEvaluation<Vector<'a>>
+    abstract ReduceOut: Mask1D option -> Monoid<'a> -> OpenCLEvaluation<Vector<'a>>
+    abstract Reduce: Monoid<'a> -> OpenCLEvaluation<Scalar<'a>>
+    abstract Transpose: unit -> OpenCLEvaluation<Matrix<'a>>
+    abstract Kronecker: Matrix<'a> -> Mask2D option -> Semiring<'a> -> OpenCLEvaluation<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<'a>) = x.Mxm y
     static member inline (@.) (x: Matrix<'a>, y: Vector<'a>) = x.Mxv y
 
-and [<AbstractClass>] Vector<'a when 'a : struct and 'a : equality>(length: int) =
-    abstract Length: int
-    default this.Length = length
-
-    abstract Clear: unit -> unit
-    abstract Extract: Mask1D option -> Vector<'a>
-    abstract Extract: int -> Scalar<'a>
-    abstract Assign: Mask1D option * Vector<'a> -> unit
-    abstract Assign: int * Scalar<'a> -> unit
-    abstract Assign: Mask1D option * Scalar<'a> -> unit
-    // abstract Dup
-    // abstract Resize
-    // abstrct Clear
-    // abstract NNZ
-    // abstract Tuples: {| Indices: int[]; Values: 'a[] |}
-
-    abstract Vxm: Matrix<'a> -> Mask1D option -> Semiring<'a> -> Vector<'a>
-    abstract EWiseAdd: Vector<'a> -> Mask1D option -> Monoid<'a> -> Vector<'a>
-    abstract EWiseMult: Vector<'a> -> Mask1D option -> Monoid<'a> -> Vector<'a>
-    abstract Apply: Mask1D option -> UnaryOp<'a, 'b> -> Vector<'b>
-    abstract Prune: Mask1D option -> UnaryOp<'a, bool> -> Vector<'a>
-    abstract Reduce: Monoid<'a> -> Scalar<'a>
-
-    abstract Mask: Mask1D option
-    abstract Complemented: Mask1D option
+
+and [<AbstractClass>] Vector<'a when 'a : struct and 'a : equality>(size: int) =
+    abstract Size: int
+    default this.Size = size
+
+    abstract Clear: unit -> OpenCLEvaluation<unit>
+    abstract Copy: unit -> OpenCLEvaluation<Vector<'a>>
+    abstract Resize: int -> OpenCLEvaluation<Vector<'a>>
+    abstract GetNNZ: unit -> OpenCLEvaluation<int>
+    abstract GetTuples: unit -> OpenCLEvaluation<{| Indices: int[]; Values: 'a[] |}>
+    abstract GetMask: bool -> OpenCLEvaluation<Mask1D option>
+
+    abstract Extract: Mask1D option -> OpenCLEvaluation<Vector<'a>>
+    abstract Extract: int -> OpenCLEvaluation<Scalar<'a>>
+    abstract Assign: Mask1D option * Vector<'a> -> OpenCLEvaluation<unit>
+    abstract Assign: int * Scalar<'a> -> OpenCLEvaluation<unit>
+    abstract Assign: Mask1D option * Scalar<'a> -> OpenCLEvaluation<unit>
+
+    abstract Vxm: Matrix<'a> -> Mask1D option -> Semiring<'a> -> OpenCLEvaluation<Vector<'a>>
+    abstract EWiseAdd: Vector<'a> -> Mask1D option -> Semiring<'a> -> OpenCLEvaluation<Vector<'a>>
+    abstract EWiseMult: Vector<'a> -> Mask1D option -> Semiring<'a> -> OpenCLEvaluation<Vector<'a>>
+    abstract Apply: Mask1D option -> UnaryOp<'a, 'b> -> OpenCLEvaluation<Vector<'b>>
+    abstract Prune: Mask1D option -> UnaryOp<'a, bool> -> OpenCLEvaluation<Vector<'a>>
+    abstract Reduce: Monoid<'a> -> OpenCLEvaluation<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: Matrix<'a>) = x.Vxm y
 
+
 and Mask1D(indices: int[], length: int, isComplemented: bool) =
     member this.Indices = indices
     member this.Length = length
@@ -85,9 +118,10 @@ and Mask1D(indices: int[], length: int, isComplemented: bool) =
     member this.Item
         with get (idx: int) : bool =
             this.Indices
-            |> Array.exists ((=) idx)
+            |> Array.contains idx
             |> (<>) this.IsComplemented
 
+
 and Mask2D(indices: (int * int)[], rowCount: int, columnCount: int, isComplemented: bool) =
     member this.Rows = indices |> Array.unzip |> fst
     member this.Columns = indices |> Array.unzip |> snd
@@ -99,5 +133,5 @@ and Mask2D(indices: (int * int)[], rowCount: int, columnCount: int, isComplement
         with get (rowIdx: int, colIdx: int) : bool =
             (this.Rows, this.Columns)
             ||> Array.zip
-            |> Array.exists ((=) (rowIdx, colIdx))
+            |> Array.contains (rowIdx, colIdx)
             |> (<>) this.IsComplemented

src/GraphBLAS-sharp/Algorithms/BFS.fs

@@ -3,23 +3,69 @@ namespace GraphBLAS.FSharp.Algorithms
 open GraphBLAS.FSharp.Predefined
 open GraphBLAS.FSharp.Helpers
 open GraphBLAS.FSharp
+open Brahma.FSharp.OpenCL.WorkflowBuilder.Basic
+open Brahma.FSharp.OpenCL.WorkflowBuilder.Evaluation
+
+[<AutoOpen>]
+module Ext =
+    type OpenCLEvaluationBuilder with
+        member this.While(guard, body) =
+            if not <| guard ()
+            then this.Zero()
+            else this.Bind(body, fun () -> this.While(guard, body))
+
+        member this.Delay(f) = f ()
+
+        member this.Zero() = this.Return()
+
+        member this.Combine(a, b) = this.Bind(a, fun () -> b)
 
 [<AutoOpen>]
 module BFS =
-    let levelBFS (matrix: Matrix<bool>) (source: int) : Vector<int> =
+    let levelBFS (matrix: Matrix<bool>) (source: int) : OpenCLEvaluation<Vector<int>> =
         let vertexCount = matrix.RowCount
-        let levels = DenseVector(Array.zeroCreate vertexCount, IntegerMonoid.add)
+        let levels = Vector.Dense(Array.zeroCreate vertexCount, IntegerMonoid.add)
 
-        let frontier = SparseVector(vertexCount, [source, true])
+        let frontier = Vector.Sparse(vertexCount, [source, true])
         let mutable currentLevel = 1
 
-        while !> (frontier.Reduce BooleanMonoid.any) && currentLevel < vertexCount do
-            levels.Assign(frontier.Mask, Scalar currentLevel)
-            frontier.Clear()
-            frontier.Assign(levels.Complemented, (frontier @. matrix) levels.Complemented BooleanSemiring.anyAll)
-            currentLevel <- currentLevel + 1
+        // let inline ($) (a: Mask1D option -> 'a) (b: Mask1D option) = a <| b
+        let inline (?<-) (a: Vector<'a>) (b: Mask1D option) (c: Scalar<'a>) = a.Assign(b, c)
+        let inline (<@@>) (a: Vector<'a>) (b: Mask1D option) (c: Scalar<'a>) = ()
+
+
+
+        // let frontier = (@.) frontier
+
+        // let a = levels.AssignE <| frontier.Mask
+        // let a = levels $ frontier.Mask <| Scalar currentLevel
+        let a = levels ? frontier.Mask <- Scalar currentLevel
+
+
+
+
+        // opencl {
+        //     while currentLevel < vertexCount do
+        //         do! levels.Assign(frontier.Mask, Scalar currentLevel)
+        //         // let! frontier = frontier @. matrix <|| (levels.Complemented, BooleanSemiring.anyAll)
+        //         let! frontier = frontier @. matrix <| {| Mask = levels.Complemented; SR = BooleanSemiring.anyAll |}
+        //         currentLevel <- currentLevel + 1
+        //         // let! a = frontier.Reduce BooleanMonoid.any
+        //         // let s = !> a
+        //         let a = levels.Assign $ frontier.Mask
+
+        //     return levels
+        // }
+
+        // while !> (frontier.Reduce BooleanMonoid.any) && currentLevel < vertexCount do
+        //     levels.Assign(frontier.Mask, Scalar currentLevel)
+        //     frontier.Clear()
+        //     frontier.Assign(levels.Complemented, (frontier @. matrix) levels.Complemented BooleanSemiring.anyAll)
+        //     currentLevel <- currentLevel + 1
+
+        // upcast levels
+
 
-        upcast levels
 
     // let parentBFS (matrix: Matrix<bool>) (source: int) : Vector<int> =
     //     let vertexCount = matrix.RowCount