refactor: Clean up migrated tests

Author: JimmyMAndersson

Sources/StatKit/Descriptive Statistics/Association/Correlation.swift

@@ -123,7 +123,7 @@ public extension Collection {
 }
 
 /// The different supported variants of the Kendall Tau coefficient.
-public enum KendallTauVariant: CaseIterable {
+public enum KendallTauVariant: CaseIterable, Sendable {
   /// The original Tau statistic defined in 1938.
   /// Tau-a does not make adjustments for rank ties.
   case a

Sources/StatKit/Descriptive Statistics/Central Tendency/MeanStrategy.swift

@@ -1,5 +1,5 @@
 /// An enumeration specififying a type of mean value calculation.
-public enum MeanStrategy: CaseIterable {
+public enum MeanStrategy: CaseIterable, Sendable {
   /// A case specifying the arithmetic mean.
   case arithmetic
 

Sources/StatKit/Descriptive Statistics/Central Tendency/MedianStrategy.swift

@@ -1,5 +1,5 @@
 /// Determines which value to pick in cases where the number of elements in a collection are even.
-public enum MedianStrategy {
+public enum MedianStrategy: CaseIterable, Sendable {
   /// Returns the higher of the two middle values if there is an even number of elements in the collection.
   case high
   /// Returns the lower of the two middle values if there is an even number of elements in the collection.

Sources/StatKit/Descriptive Statistics/Quantile.swift

@@ -77,7 +77,7 @@ public extension Collection {
 }
 
 /// A method for computing quantiles.
-public enum QuantileEstimationMethod {
+public enum QuantileEstimationMethod: CaseIterable, Sendable {
   /// Computes the quantile usign the inverse empirical CDF.
   case inverseEmpiricalCDF
   /// Computes the quantile usign the inverse empirical CDF, and takes the arithmetic mean at discontinuities.

Sources/StatKit/Descriptive Statistics/Ranking/RankingStrategy.swift

@@ -18,7 +18,7 @@ protocol RankingStrategyProtocol {
 }
 
 /// A calculation strategy for ranking comparable variables.
-public enum RankingStrategy {
+public enum RankingStrategy: CaseIterable, Sendable {
   /// The Fractional ranking strategy.
   case fractional
   /// The Standard Competition ranking strategy.

Tests/StatKitTests/Descriptive Statistics Tests/Dispersion Tests/VarianceTests.swift

@@ -3,12 +3,15 @@ import StatKit
 
 @Suite("Variance Tests", .tags(.dispersion))
 struct VarianceTests {
-  @Test("Valid data returns correct variance", arguments: [
-    ((1 ... 5).map(\.realValue), 2.5, DataSetComposition.sample),
-    ((-5 ... 5).map(\.realValue), 11.0, DataSetComposition.sample),
-    ((1 ... 5).map(\.realValue), 2, DataSetComposition.population),
-    ((-5 ... 5).map(\.realValue), 10, DataSetComposition.population),
-  ])
+  @Test(
+    "Valid data returns correct variance",
+    arguments: [
+      ((1 ... 5).map(\.realValue), 2.5, DataSetComposition.sample),
+      ((-5 ... 5).map(\.realValue), 11.0, DataSetComposition.sample),
+      ((1 ... 5).map(\.realValue), 2, DataSetComposition.population),
+      ((-5 ... 5).map(\.realValue), 10, DataSetComposition.population),
+    ] as [([Double], Double, DataSetComposition)]
+  )
   func validData(data: [Double], expectedVariance: Double, composition: DataSetComposition) {
     #expect(data.variance(variable: \.self, from: composition).isApproximatelyEqual(to: expectedVariance, absoluteTolerance: 1e-6))
   }

Tests/StatKitTests/Descriptive Statistics Tests/Ranking Tests/RankingTests.swift

@@ -3,86 +3,101 @@ import StatKit
 
 @Suite("Ranking Tests", .tags(.ranking))
 struct RankingTests {
-  private typealias RankingInput<T> = [([T], (T, T) -> Bool, [Double], RankingStrategy)]
+  private typealias RankingInput<T> = [([T], [Double], RankingStrategy)]
 
   @Test(
-    "Valid integer data sets produce valid rankings",
+    "Valid integer data sets produce valid rankings for less than ordering",
     arguments: [
-      ([1, 2, 3, 4, 5], >, [5, 4, 3, 2, 1], .dense),
-      ([1, 3, 4, 3, 5], >, [4, 3, 2, 3, 1], .dense),
-      ([1, 2, 3, 4, 5], <, [1, 2, 3, 4, 5], .dense),
-      ([1, 3, 4, 3, 5], <, [1, 2, 3, 2, 4], .dense),
-      ([], <, [], .dense),
-      ([1], <, [1], .dense),
-      ([1, 3, 5, 3], <=, [1, 2, 3, 2], .dense),
-
-      ([1, 3, 4, 2, 5], >, [5, 3, 2, 4, 1], .fractional),
-      ([1, 3, 4, 3, 5], >, [5, 3.5, 2, 3.5, 1], .fractional),
-      ([1, 3, 4, 2, 5], <, [1, 3, 4, 2, 5], .fractional),
-      ([1, 3, 4, 3, 5], <, [1, 2.5, 4, 2.5, 5], .fractional),
-      ([], <, [], .fractional),
-      ([1], <, [1], .fractional),
-      ([1, 3, 5, 3], <=, [1, 2.5, 4, 2.5], .fractional),
-
-      ([1, 3, 4, 2, 5], >, [5, 3, 2, 4, 1], .modifiedCompetition),
-      ([1, 3, 4, 3, 5], >, [5, 4, 2, 4, 1], .modifiedCompetition),
-      ([1, 3, 4, 2, 5], <, [1, 3, 4, 2, 5], .modifiedCompetition),
-      ([1, 3, 4, 3, 5, 3, 3], <, [1, 5, 6, 5, 7, 5, 5], .modifiedCompetition),
-      ([], <, [], .modifiedCompetition),
-      ([1], <, [1], .modifiedCompetition),
-      ([1, 3, 5, 3], <=, [1, 3, 4, 3], .modifiedCompetition),
-
-      ([1, 3, 4, 2, 5], >, [5, 3, 2, 4, 1], .standardCompetition),
-      ([1, 3, 4, 3, 5], >, [5, 3, 2, 3, 1], .standardCompetition),
-      ([1, 3, 4, 2, 5], <, [1, 3, 4, 2, 5], .standardCompetition),
-      ([1, 3, 4, 3, 5, 3, 3], <, [1, 2, 6, 2, 7, 2, 2], .standardCompetition),
-      ([], <, [], .standardCompetition),
-      ([1], <, [1], .standardCompetition),
-      ([1, 3, 5, 3], <=, [1, 2, 4, 2], .standardCompetition),
-
-      ([1, 3, 4, 2, 5], >, [5, 3, 2, 4, 1], .ordinal),
-      ([1, 3, 4, 3, 5], >, [5, 3, 2, 4, 1], .ordinal),
-      ([1, 3, 4, 2, 5], <, [1, 3, 4, 2, 5], .ordinal),
-      ([1, 3, 4, 3, 5, 3, 3], <, [1, 2, 6, 3, 7, 4, 5], .ordinal),
-      ([], <, [], .ordinal),
-      ([1], <, [1], .ordinal),
-      ([1, 3, 5, 3], <=, [1, 2, 4, 3], .ordinal),
+      ([1, 2, 3, 4, 5], [1, 2, 3, 4, 5], .dense),
+      ([1, 3, 4, 3, 5], [1, 2, 3, 2, 4], .dense),
+      ([], [], .dense),
+      ([1], [1], .dense),
+      ([1, 3, 5, 3], [1, 2, 3, 2], .dense),
+
+      ([1, 3, 4, 2, 5], [1, 3, 4, 2, 5], .fractional),
+      ([1, 3, 4, 3, 5], [1, 2.5, 4, 2.5, 5], .fractional),
+      ([], [], .fractional),
+      ([1], [1], .fractional),
+      ([1, 3, 5, 3], [1, 2.5, 4, 2.5], .fractional),
+
+      ([1, 3, 4, 2, 5], [1, 3, 4, 2, 5], .modifiedCompetition),
+      ([1, 3, 4, 3, 5, 3, 3], [1, 5, 6, 5, 7, 5, 5], .modifiedCompetition),
+      ([], [], .modifiedCompetition),
+      ([1], [1], .modifiedCompetition),
+      ([1, 3, 5, 3], [1, 3, 4, 3], .modifiedCompetition),
+
+      ([1, 3, 4, 2, 5], [1, 3, 4, 2, 5], .standardCompetition),
+      ([1, 3, 4, 3, 5, 3, 3], [1, 2, 6, 2, 7, 2, 2], .standardCompetition),
+      ([], [], .standardCompetition),
+      ([1], [1], .standardCompetition),
+      ([1, 3, 5, 3], [1, 2, 4, 2], .standardCompetition),
+
+      ([1, 3, 4, 2, 5], [1, 3, 4, 2, 5], .ordinal),
+      ([1, 3, 4, 3, 5, 3, 3], [1, 2, 6, 3, 7, 4, 5], .ordinal),
+      ([], [], .ordinal),
+      ([1], [1], .ordinal),
+      ([1, 3, 5, 3], [1, 2, 4, 3], .ordinal),
+    ] as RankingInput<Int>
+  )
+  func validIntegerDataSetsLessThanOrdering(
+    data: [Int],
+    expectedRank: [Double],
+    strategy: RankingStrategy
+  ) async {
+    #expect(data.rank(variable: \.self, by: <, strategy: strategy) == expectedRank)
+  }
+
+  @Test(
+    "Valid integer data sets produce valid rankings for greater than ordering",
+    arguments: [
+      ([1, 2, 3, 4, 5], [5, 4, 3, 2, 1], .dense),
+      ([1, 3, 4, 3, 5], [4, 3, 2, 3, 1], .dense),
+
+      ([1, 3, 4, 2, 5], [5, 3, 2, 4, 1], .fractional),
+      ([1, 3, 4, 3, 5], [5, 3.5, 2, 3.5, 1], .fractional),
+
+      ([1, 3, 4, 2, 5], [5, 3, 2, 4, 1], .modifiedCompetition),
+      ([1, 3, 4, 3, 5], [5, 4, 2, 4, 1], .modifiedCompetition),
+
+      ([1, 3, 4, 2, 5], [5, 3, 2, 4, 1], .standardCompetition),
+      ([1, 3, 4, 3, 5], [5, 3, 2, 3, 1], .standardCompetition),
+
+      ([1, 3, 4, 2, 5], [5, 3, 2, 4, 1], .ordinal),
+      ([1, 3, 4, 3, 5], [5, 3, 2, 4, 1], .ordinal),
     ] as RankingInput<Int>
   )
-  func validIntegerDataSets(
+  func validIntegerDataSetsGreaterThanOrdering(
     data: [Int],
-    ordering: @escaping (Int, Int) -> Bool,
     expectedRank: [Double],
     strategy: RankingStrategy
   ) async {
-    #expect(data.rank(variable: \.self, by: ordering, strategy: strategy) == expectedRank)
+    #expect(data.rank(variable: \.self, by: >, strategy: strategy) == expectedRank)
   }
 
   @Test(
     "Valid floating point data sets produce valid rankings",
     arguments: [
-      ([.infinity, .pi, -.infinity, -.pi], <, [4, 3, 1, 2], .dense),
-      ([-.infinity, -.infinity, .infinity, .infinity], <, [1, 1, 2, 2], .dense),
+      ([.infinity, .pi, -.infinity, -.pi], [4, 3, 1, 2], .dense),
+      ([-.infinity, -.infinity, .infinity, .infinity], [1, 1, 2, 2], .dense),
 
-      ([.infinity, .pi, -.infinity, -.pi], <, [4, 3, 1, 2], .fractional),
-      ([-.infinity, -.infinity, .infinity, .infinity], <, [1.5, 1.5, 3.5, 3.5], .fractional),
+      ([.infinity, .pi, -.infinity, -.pi], [4, 3, 1, 2], .fractional),
+      ([-.infinity, -.infinity, .infinity, .infinity], [1.5, 1.5, 3.5, 3.5], .fractional),
 
-      ([.infinity, .pi, -.infinity, -.pi], <, [4, 3, 1, 2], .modifiedCompetition),
-      ([-.infinity, -.infinity, .infinity, .infinity], <, [2, 2, 4, 4], .modifiedCompetition),
+      ([.infinity, .pi, -.infinity, -.pi], [4, 3, 1, 2], .modifiedCompetition),
+      ([-.infinity, -.infinity, .infinity, .infinity], [2, 2, 4, 4], .modifiedCompetition),
 
-      ([.infinity, .pi, -.infinity, -.pi], <, [4, 3, 1, 2], .standardCompetition),
-      ([-.infinity, -.infinity, .infinity, .infinity], <, [1, 1, 3, 3], .standardCompetition),
+      ([.infinity, .pi, -.infinity, -.pi], [4, 3, 1, 2], .standardCompetition),
+      ([-.infinity, -.infinity, .infinity, .infinity], [1, 1, 3, 3], .standardCompetition),
 
-      ([.infinity, .pi, -.infinity, -.pi], <, [4, 3, 1, 2], .ordinal),
-      ([-.infinity, -.infinity, .infinity, .infinity], <, [1, 2, 3, 4], .ordinal),
+      ([.infinity, .pi, -.infinity, -.pi], [4, 3, 1, 2], .ordinal),
+      ([-.infinity, -.infinity, .infinity, .infinity], [1, 2, 3, 4], .ordinal),
     ] as RankingInput<Double>
   )
   func validFloatingPointDataSets(
     data: [Double],
-    ordering: @escaping (Double, Double) -> Bool,
     expectedRank: [Double],
     strategy: RankingStrategy
   ) async {
-    #expect(data.rank(variable: \.self, by: ordering, strategy: strategy) == expectedRank)
+    #expect(data.rank(variable: \.self, by: <, strategy: strategy) == expectedRank)
   }
 }

Tests/StatKitTests/Descriptive Statistics Tests/SummationTests.swift

@@ -24,7 +24,7 @@ struct SummationTests {
       ([1, 2, 3, 4, .infinity], .infinity),
     ] as [([Double], Double)]
   )
-  func validIntegerData(data: [Double], expectedSum: Double) {
+  func validFloatingPointData(data: [Double], expectedSum: Double) {
     #expect(data.sum(over: \.self) == expectedSum)
   }