Assume folder is associative

Author: Danil-Zaripov

QuadTree.Tests/Tests.Matrix.fs

@@ -282,7 +282,7 @@ let ``fold -> sum`` () =
 
     let expected = 18
 
-    let actual = Option.get <| Matrix.fold op_add None m1
+    let actual = Option.get <| Matrix.foldAssociative op_add None m1
 
     Assert.Equal(expected, actual)
 
@@ -412,6 +412,6 @@ let ``Fold sum`` () =
 
     let expected = 6
 
-    let actual = fold op_add None m1 |> Option.get
+    let actual = foldAssociative op_add None m1 |> Option.get
 
     Assert.Equal(expected, actual)

QuadTree/Matrix.fs

@@ -180,20 +180,22 @@ let map2 (matrix1: SparseMatrix<_>) (matrix2: SparseMatrix<_>) f =
     else
         (Error.InconsistentSizeOfArguments(matrix1, matrix2)) |> Result.Failure
 
-let fold (folder: 'State option -> 'T option -> 'State option) (state: 'State option) (matrix: SparseMatrix<'T>) =
-    let rec traverse tree (size: uint64<storageSize>) (state: 'State option) =
+let foldAssociative (folder: 'T option -> 'T option -> 'T option) (state: 'T option) (matrix: SparseMatrix<'T>) =
+    let rec traverse tree (size: uint64<storageSize>) (state: 'T option) =
         match tree with
         | Leaf Dummy -> state
         | Leaf(UserValue v) ->
             let area = (uint64 size) * (uint64 size)
 
-            let rec foldArea count accum =
-                if count = 0UL then
+            let rec foldValue size accum =
+                if size = 1UL then
                     accum
                 else
-                    foldArea (count - 1UL) (folder accum v)
+                    let halfSize = size / 2UL
 
-            foldArea area state
+                    foldValue halfSize (folder accum accum)
+
+            folder state (foldValue area v)
         | Node(nw, ne, sw, se) ->
             let halfSize = size / 2UL
 

QuadTree/TriangleCount.fs

@@ -36,7 +36,7 @@ let triangle_count (graph: Matrix.SparseMatrix<_>) =
 
     let result =
         match CMasked with
-        | Result.Success matrix -> Result.Success(Matrix.fold op_add None matrix)
+        | Result.Success matrix -> Result.Success(Matrix.foldAssociative op_add None matrix)
         | Result.Failure e -> Result.Failure e
 
     result