add property tests, improve benchmarks, add parallel module

AVLSet_Solution.slnx

@@ -6,6 +6,7 @@
     <Project Path="src/AVLSet.Library/AVLSet.Library.fsproj" />
   </Folder>
   <Folder Name="/tests/">
+    <Project Path="tests/AVLSet.PropertyTests/AVLSet.PropertyTests.fsproj" />
     <Project Path="tests/AVLSet.UnitTests/AVLSet.UnitTests.fsproj" />
   </Folder>
 </Solution>

README.md

@@ -86,29 +86,41 @@ The `AVLSet` module provides a comprehensive interface:
 |:---|:---|:---|
 | **add** | `'a -> AVLTree<'a> -> AVLTree<'a>` | Adds an element. |
 | **delete** | `'a -> AVLTree<'a> -> AVLTree<'a>` | Removes an element. |
-| **contains** | `'a -> AVLTree<'a> -> bool` | Checks membership. |
+| **contains** | `'a -> AVLTree<'a> -> AVLTree<'a>` | Checks membership. |
+| **copy** | `'a -> AVLTree<'a> -> bool` | Copies an set. |
 | **union** | `AVLTree<'a> -> AVLTree<'a> -> AVLTree<'a>` | Standard union ($A \cup B$). |
 | **intersection** | `AVLTree<'a> -> AVLTree<'a> -> AVLTree<'a>` | Standard intersection ($A \cap B$). |
 | **difference** | `AVLTree<'a> -> AVLTree<'a> -> AVLTree<'a>` | Standard difference ($A \setminus B$). |
 | **symmDifference** | `AVLTree<'a> -> AVLTree<'a> -> AVLTree<'a>` | Standard symmetrical difference ($A \vartriangle B$). |
-| **parallel(Union/Intersection/Difference/SymmDiff)**| `ParallelOptions -> AVLTree<'a> -> AVLTree<'a> -> AVLTree<'a>` | Multi-threaded set-theoretic operations. |
-| **(union/intersection/difference/symmDiff)Traversal**| `AVLTree<'a> -> AVLTree<'a> -> AVLTree<'a>` | Set-theoretic operations via tree traversal. |
+| **Traversal.{union/intersection/difference/symmDiff}**| `AVLTree<'a> -> AVLTree<'a> -> AVLTree<'a>` | Set-theoretic operations via tree traversal. |
+
+The `ParallelAVLSet` module provides an interface for parallel set-theoretic operations:
+| **union** | `option<int> -> AVLTree<'a> -> AVLTree<'a> -> AVLTree<'a>` | Parallel union ($A \cup B$). |
+| **intersection** | `option<int> -> AVLTree<'a> -> AVLTree<'a> -> AVLTree<'a>` | Parallel intersection ($A \cap B$). |
+| **difference** | `option<int> -> AVLTree<'a> -> AVLTree<'a> -> AVLTree<'a>` | Parallel difference ($A \setminus B$). |
+| **symmDifference** | `option<int> -> AVLTree<'a> -> AVLTree<'a> -> AVLTree<'a>` | Parallel symmetrical difference ($A \vartriangle B$). |
+| **{union/intersection/difference/symmDiff}Async** | `option<int> -> AVLTree<'a> -> AVLTree<'a> -> AVLTree<'a>` | Creates an asynchronous computation for set-theoretic operations. |
 
 ---
 
 ## Project Structure
 ```text
 /src
-└── AVLSet.Library       
-    ├── AVLSet.Library.fsproj
-    └── Library.fs
+    └── AVLSet.Library    
+        ├── AssemblyInfo.fs
+        ├── AVLSet.Library.fsproj
+        ├── Library.fs
+        └── LibraryParallel.fs
 /tests
-└── AVLSet.UnitTests     
-    ├── AVLSet.UnitTests.fsproj
-    └── Tests.fs
+    └── AVLSet.UnitTests     
+    │   ├── AVLSet.UnitTests.fsproj
+    │   └── Tests.fs
+    └── AVLSet.PropertyTests     
+        ├── AVLSet.PropertyTests.fsproj
+        └── Tests.fs
 /benchmarks
-└── AVLSet.Benchmarks    
-    ├── AVLSet.Benchmarks.fsproj
-    ├── Benchmarks.fs
-    └── Program.fs
+    └── AVLSet.Benchmarks    
+        ├── AVLSet.Benchmarks.fsproj
+        ├── Benchmarks.fs
+        └── Program.fs
 ```

benchmarks/AVLSet.Benchmarks/Benchmarks.fs

@@ -1,132 +1,184 @@
 namespace AVLSet.Benchmarks
 
-open System.Threading.Tasks
-open BenchmarkDotNet.Diagnosers
 open BenchmarkDotNet.Attributes
 open BenchmarkDotNet.Configs
 open AVLSet.Library
+open AVLSet.Library.Parallel
 
 [<GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)>]
 [<CategoriesColumn>]
 [<HtmlExporter>]
 [<MemoryDiagnoser>]
-[<ThreadingDiagnoser>]
-[<HardwareCounters(HardwareCounter.CacheMisses, HardwareCounter.BranchMispredictions)>]
-type SetBenchmarks() =
+type SingleOpsBenchmark() =
     let rnd = System.Random(1234561)
 
-    [<Params(100, 10000, 1000000)>]
+    [<Params(100, 10000, 100000)>]
     [<DefaultValue>]
     val mutable public A: int
 
-    [<Params(100, 1000, 100000)>]
     [<DefaultValue>]
-    val mutable public B: int
+    val mutable public rndInt: int
 
-    [<Params("Random", "Sorted")>]
     [<DefaultValue>]
-    val mutable public DataTypeA: string
+    val mutable public setA: AVLSet<int>
+
+    [<GlobalSetup>]
+    member self.Setup() =
+        self.rndInt <- rnd.Next(self.A + 1, self.A + 1000)
+
+        let dataA = Array.init self.A (fun _ -> rnd.Next())
+
+        self.setA <- dataA |> Array.fold (fun (set: AVLSet<int>) v -> AVLSet.add v set) AVLSet.empty
+
+    [<Benchmark>]
+    [<BenchmarkCategory("Adding")>]
+    member self.AddingOneElement() = AVLSet.add self.rndInt self.setA
 
-    [<Params(1, 2, 4, 8)>]
+    [<Benchmark>]
+    [<BenchmarkCategory("Deleting")>]
+    member self.DeletingOneElement() = AVLSet.delete self.rndInt self.setA
+
+
+[<GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)>]
+[<CategoriesColumn>]
+[<HtmlExporter>]
+[<MemoryDiagnoser>]
+type SequentialSetsBenchmark() =
+    let rnd = System.Random(1234561)
+
+    [<Params(100, 10000, 100000)>]
     [<DefaultValue>]
-    val mutable public Threads: int
+    val mutable public A: int
 
+    [<Params(100, 10000)>]
     [<DefaultValue>]
-    val mutable public rndInt: int
+    val mutable public B: int
 
     [<DefaultValue>]
-    val mutable public setA: AVLTree<int>
+    val mutable public setA: AVLSet<int>
 
     [<DefaultValue>]
-    val mutable public setB: AVLTree<int>
+    val mutable public setB: AVLSet<int>
 
     [<GlobalSetup>]
     member self.Setup() =
-        self.rndInt <- rnd.Next(self.A + 1, self.A + 1000)
-
-        let dataA =
-            match self.DataTypeA with
-            | "Random" -> Array.init self.A (fun _ -> rnd.Next())
-            | _ -> [| 1 .. self.A |]
+        let dataA = Array.init self.A (fun _ -> rnd.Next())
 
         let dataB = Array.init self.B (fun _ -> rnd.Next())
 
-        self.setA <- dataA |> Array.fold (fun s v -> AVLSet.add v s) AVLSet.empty
-        self.setB <- dataB |> Array.fold (fun s v -> AVLSet.add v s) AVLSet.empty
+        self.setA <- dataA |> Array.fold (fun (set: AVLSet<int>) v -> AVLSet.add v set) AVLSet.empty
+
+        self.setB <- dataB |> Array.fold (fun (set: AVLSet<int>) v -> AVLSet.add v set) AVLSet.empty
+
+    [<Benchmark(Baseline = true)>]
+    [<BenchmarkCategory("Union")>]
+    member self.SequentialUnion() = AVLSet.union self.setA self.setB
 
     [<Benchmark>]
-    [<BenchmarkCategory("Adding")>]
-    member self.``Adding one element``() = AVLSet.add self.rndInt self.setA
+    [<BenchmarkCategory("Union")>]
+    member self.UnionViaTreeTraversal() =
+        AVLSet.Traversal.union self.setA self.setB
+
+    [<Benchmark(Baseline = true)>]
+    [<BenchmarkCategory("Intersection")>]
+    member self.SequentialIntersection() = AVLSet.intersection self.setA self.setB
 
     [<Benchmark>]
-    [<BenchmarkCategory("Deleting")>]
-    member self.``Deleting one element``() = AVLSet.delete self.rndInt self.setA
+    [<BenchmarkCategory("Intersection")>]
+    member self.IntersectionViaTreeTraversal() =
+        AVLSet.Traversal.intersection self.setA self.setB
 
     [<Benchmark(Baseline = true)>]
-    [<BenchmarkCategory("Union")>]
-    member self.``Sequential union``() = AVLSet.union self.setA self.setB
+    [<BenchmarkCategory("Difference")>]
+    member self.SequentialDifference() = AVLSet.difference self.setA self.setB
 
     [<Benchmark>]
-    [<BenchmarkCategory("Union")>]
-    member self.``Union via tree traversal``() =
-        AVLSet.unionTraversal self.setA self.setB
+    [<BenchmarkCategory("Difference")>]
+    member self.DifferenceViaTreeTraversal() =
+        AVLSet.Traversal.difference self.setA self.setB
+
+    [<Benchmark(Baseline = true)>]
+    [<BenchmarkCategory("Symmetrical Difference")>]
+    member self.SequentialSymmetricalDifference() =
+        AVLSet.symmDifference self.setA self.setB
 
     [<Benchmark>]
-    [<BenchmarkCategory("Union")>]
-    member self.``Parallel union with threads``() =
-        let opts = ParallelOptions()
-        opts.MaxDegreeOfParallelism <- self.Threads
+    [<BenchmarkCategory("Symmetrical Difference")>]
+    member self.SymmetricalDifferenceViaTreeTraversal() =
+        AVLSet.Traversal.symmDifference self.setA self.setB
+
+
+[<ShortRunJob>]
+[<GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)>]
+[<CategoriesColumn>]
+[<HtmlExporter>]
+[<MemoryDiagnoser>]
+[<ThreadingDiagnoser>]
+type ParallelSetsBenchmark() =
+    let rnd = System.Random(1234561)
+
+    [<Params(1000, 10000, 100000)>]
+    [<DefaultValue>]
+    val mutable public A: int
+
+    [<Params(100, 10000)>]
+    [<DefaultValue>]
+    val mutable public B: int
+
+    [<Params(1, 2, 4)>]
+    [<DefaultValue>]
+    val mutable public threads: int
+
+    [<DefaultValue>]
+    val mutable public setA: AVLSet<int>
+
+    [<DefaultValue>]
+    val mutable public setB: AVLSet<int>
+
+    [<GlobalSetup>]
+    member self.Setup() =
+        let dataA = Array.init self.A (fun _ -> rnd.Next())
+
+        let dataB = Array.init self.B (fun _ -> rnd.Next())
+
+        self.setA <- dataA |> Array.fold (fun (set: AVLSet<int>) v -> AVLSet.add v set) AVLSet.empty
+
+        self.setB <- dataB |> Array.fold (fun (set: AVLSet<int>) v -> AVLSet.add v set) AVLSet.empty
 
-        AVLSet.parallelUnion opts self.setA self.setB
 
     [<Benchmark(Baseline = true)>]
-    [<BenchmarkCategory("Intersection")>]
-    member self.``Sequential intersection``() = AVLSet.intersection self.setA self.setB
+    [<BenchmarkCategory("Union")>]
+    member self.SequentialUnion() = AVLSet.union self.setA self.setB
 
     [<Benchmark>]
+    [<BenchmarkCategory("Union")>]
+    member self.ParallelUnionWithThreads() =
+        ParallelAVLSet.union (Some self.threads) self.setA self.setB
+
+    [<Benchmark(Baseline = true)>]
     [<BenchmarkCategory("Intersection")>]
-    member self.``Intersection via tree traversal``() =
-        AVLSet.intersectionTraversal self.setA self.setB
+    member self.SequentialIntersection() = AVLSet.intersection self.setA self.setB
 
     [<Benchmark>]
     [<BenchmarkCategory("Intersection")>]
-    member self.``Parallel intersection with threads``() =
-        let opts = ParallelOptions()
-        opts.MaxDegreeOfParallelism <- self.Threads
-
-        AVLSet.parallelIntersection opts self.setA self.setB
+    member self.ParallelIntersectionWithThreads() =
+        ParallelAVLSet.intersection (Some self.threads) self.setA self.setB
 
     [<Benchmark(Baseline = true)>]
     [<BenchmarkCategory("Difference")>]
-    member self.``Sequential difference``() = AVLSet.difference self.setA self.setB
-
-    [<Benchmark>]
-    [<BenchmarkCategory("Difference")>]
-    member self.``Difference via tree traversal``() =
-        AVLSet.differenceTraversal self.setA self.setB
+    member self.SequentialDifference() = AVLSet.difference self.setA self.setB
 
     [<Benchmark>]
     [<BenchmarkCategory("Difference")>]
-    member self.``Parallel difference with threads``() =
-        let opts = ParallelOptions()
-        opts.MaxDegreeOfParallelism <- self.Threads
-
-        AVLSet.parallelDifference opts self.setA self.setB
+    member self.ParallelDifferenceWithThreads() =
+        ParallelAVLSet.difference (Some self.threads) self.setA self.setB
 
     [<Benchmark(Baseline = true)>]
     [<BenchmarkCategory("Symmetrical Difference")>]
-    member self.``Sequential symmetrical difference``() =
+    member self.SequentialSymmetricalDifference() =
         AVLSet.symmDifference self.setA self.setB
 
     [<Benchmark>]
     [<BenchmarkCategory("Symmetrical Difference")>]
-    member self.``Symmetrical difference via tree traversal``() =
-        AVLSet.symmDifferenceTraversal self.setA self.setB
-
-    [<Benchmark>]
-    [<BenchmarkCategory("Symmetrical Difference")>]
-    member self.``Parallel symmetrical difference with threads``() =
-        let opts = ParallelOptions()
-        opts.MaxDegreeOfParallelism <- self.Threads
-
-        AVLSet.parallelSymmDifference opts self.setA self.setB
+    member self.ParallelSymmetricalDifferenceWithThreads() =
+        ParallelAVLSet.symmDifference (Some self.threads) self.setA self.setB

benchmarks/AVLSet.Benchmarks/Program.fs

@@ -1,7 +1,12 @@
 open BenchmarkDotNet.Running
-open AVLSet.Benchmarks
 
 [<EntryPoint>]
-let main args =
-    BenchmarkRunner.Run<SetBenchmarks>() |> ignore
+let main argv =
+    let benchmarks =
+        BenchmarkSwitcher
+            [| typeof<AVLSet.Benchmarks.SingleOpsBenchmark>
+               typeof<AVLSet.Benchmarks.SequentialSetsBenchmark>
+               typeof<AVLSet.Benchmarks.ParallelSetsBenchmark> |]
+
+    benchmarks.Run argv |> ignore
     0

src/AVLSet.Library/AVLSet.Library.fsproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>net10.0</TargetFramework>
@@ -7,6 +7,7 @@
 
   <ItemGroup>
     <Compile Include="Library.fs" />
+    <Compile Include="LibraryParallel.fs" />
   </ItemGroup>
 
 </Project>