Yet another approach

Author: nalimilan

src/extras.jl

@@ -233,7 +233,10 @@ Provide the default label format for the `cut(x, ngroups)` method.
 quantile_formatter(from, to, i; leftclosed, rightclosed) =
     string("Q", i, ": ", leftclosed ? "[" : "(", from, ", ", to, rightclosed ? "]" : ")")
 
-"""Find first value in data which is greater than each quantile in ``qs``."""
+"""
+Find first value in (sorted) `v` which is greater than or equal to each quantile
+in (sorted) `qs`.
+"""
 function find_breaks(v::AbstractVector, qs::AbstractVector)
     n = length(qs)
     breaks = similar(v, n)
@@ -242,7 +245,8 @@ function find_breaks(v::AbstractVector, qs::AbstractVector)
     i = 1
     q = qs[1]
     @inbounds for x in v
-        if x > q
+        # Use isless and isequal to differentiate -0.0 from 0.0
+        if isless(q, x) || isequal(q, x)
             breaks[i] = x
             i += 1
             i > n && break
@@ -253,7 +257,6 @@ function find_breaks(v::AbstractVector, qs::AbstractVector)
     for i in i:n
         breaks[i] = q
     end
-    @show breaks
     return breaks
 end
 
@@ -264,10 +267,8 @@ end
 
 Cut a numeric array into `ngroups` quantiles.
 
-Cutpoints differ from those returned by `Statistics.quantile` as they are suited
-for intervals closed on the left and taken from actual values in `x`. However,
-group assignments are identical to those which would be obtained with type 1
-quantiles if intervals were closed on the right.
+This is equivalent to `cut(x, quantile(x, (0:ngroups)/ngroups))`,
+but breaks are taken from actual data values instead of estimated quantiles.
 
 If `x` contains `missing` values, they are automatically skipped when computing
 quantiles.

test/15_extras.jl

@@ -254,21 +254,30 @@ end
     fmt = (from, to, i; leftclosed, rightclosed) -> (i % 2 == 0 ? to : 0.0)
     @test_throws ArgumentError cut(1:8, 0:2:10, labels=fmt)
 
-    x = cut([fill(1, 10); 4], 2)
-    @test x == [fill("Q1: [1, 4)", 10); "Q2: [4, 4]"]
-    @test levels(x) == ["Q1: [1, 4)", "Q2: [4, 4]"]
+    @test_throws ArgumentError cut([fill(1, 10); 4], 2)
+    x = cut([fill(1, 10); 4], 2, allowempty=true)
+    @test unique(x) == ["Q2: [1, 4]"]
+    @test levels(x) == ["Q1: (1, 1)", "Q2: [1, 4]"]
     @test_throws ArgumentError cut([fill(1, 10); 4], 3)
     x = cut([fill(1, 10); 4], 3, allowempty=true)
-    @test x == [fill("Q1: [1, 4)", 10); "Q3: [4, 4]"]
+    @test unique(x) == ["Q3: [1, 4]"]
+    @test levels(x) == ["Q1: (1, 1)", "Q2: (1, 1)", "Q3: [1, 4]"]
+
+    x = cut([fill(4, 10); 1], 2)
+    @test x == [fill("Q2: [4, 4]", 10); "Q1: [1, 4)"]
+    @test levels(x) == ["Q1: [1, 4)"; "Q2: [4, 4]"]
+    @test_throws ArgumentError cut([fill(4, 10); 1], 3)
+    x = cut([fill(4, 10); 1], 3, allowempty=true)
+    @test x == [fill("Q3: [4, 4]", 10); "Q1: [1, 4)"]
     @test levels(x) == ["Q1: [1, 4)", "Q2: (4, 4)", "Q3: [4, 4]"]
 
     x = cut([fill(1, 5); fill(4, 5)], 2)
     @test x == [fill("Q1: [1, 4)", 5); fill("Q2: [4, 4]", 5)]
     @test levels(x) == ["Q1: [1, 4)", "Q2: [4, 4]"]
     @test_throws ArgumentError  cut([fill(1, 5); fill(4, 5)], 3)
     x = cut([fill(1, 5); fill(4, 5)], 3, allowempty=true)
-    @test x == [fill("Q1: [1, 4)", 5); fill("Q3: [4, 4]", 5)]
-    @test levels(x) == ["Q1: [1, 4)", "Q2: (4, 4)", "Q3: [4, 4]"]
+    @test x == [fill("Q2: [1, 4)", 5); fill("Q3: [4, 4]", 5)]
+    @test levels(x) == ["Q1: (1, 1)", "Q2: [1, 4)", "Q3: [4, 4]"]
 end
 
 @testset "cut with -0.0" begin
@@ -361,51 +370,13 @@ end
     @test levels(x) == ["Q1: [-Inf, 3.0)", "Q2: [3.0, 5.0]"]
 end
 
-@testset "cut in corner cases" begin
-    # In this case, cut(x, quantile(x, (0:36)/36)) in R generates
-    # an empty "(143,172]" level
-    # and qcut(x, 36) in Polars misses that level.
-    # Our approach uses different breaks at 143 and 182
-    x = [23, 23, 60, 76, 84, 95, 101, 108, 111, 133, 137, 143, 143, 143, 182,
-         206, 214, 241, 258, 262, 280, 289, 303, 312, 321, 323, 352, 353, 354,
-         368, 369, 373, 374, 384, 385, 386, 387, 392, 405, 406, 410, 421, 430,
-         430, 431, 442, 464, 474, 478, 479, 496, 516, 530, 534, 549, 554, 568,
-         575, 589, 590, 591, 592, 595, 596, 603, 625, 632, 632, 638, 640, 640,
-         645, 648, 690, 704, 748, 758, 771, 772, 803, 835, 839, 853, 869, 873,
-         874, 887, 911, 920, 923, 928, 933, 943, 945, 945, 947, 951, 965, 978, 980]
-
-    @test cut(x, 36) ==
-        ["Q17: [442, 474)", "Q8: [280, 312)", "Q2: [76, 101)", "Q9: [312, 323)",
-         "Q14: [387, 406)", "Q30: [835, 869)", "Q17: [442, 474)", "Q35: [947, 965)",
-         "Q2: [76, 101)", "Q11: [354, 373)", "Q32: [887, 923)", "Q12: [373, 385)",
-         "Q24: [603, 638)", "Q29: [772, 835)", "Q24: [603, 638)", "Q15: [406, 430)",
-         "Q11: [354, 373)", "Q23: [592, 603)", "Q3: [101, 133)", "Q16: [430, 442)",
-         "Q34: [933, 947)", "Q27: [648, 748)", "Q28: [748, 772)", "Q28: [748, 772)",
-         "Q21: [568, 589)", "Q18: [474, 496)", "Q32: [887, 923)", "Q11: [354, 373)",
-         "Q7: [241, 280)", "Q3: [101, 133)", "Q19: [496, 534)", "Q13: [385, 387)",
-         "Q36: [965, 980]", "Q33: [923, 933)", "Q16: [430, 442)", "Q36: [965, 980]",
-         "Q27: [648, 748)", "Q24: [603, 638)", "Q32: [887, 923)", "Q4: [133, 182)",
-         "Q22: [589, 592)", "Q1: [23, 76)", "Q5: [182, 206)", "Q28: [748, 772)",
-         "Q30: [835, 869)", "Q31: [869, 887)", "Q22: [589, 592)", "Q15: [406, 430)",
-         "Q31: [869, 887)", "Q19: [496, 534)", "Q26: [640, 648)", "Q8: [280, 312)",
-         "Q18: [474, 496)", "Q14: [387, 406)", "Q7: [241, 280)", "Q30: [835, 869)",
-         "Q3: [101, 133)", "Q9: [312, 323)", "Q4: [133, 182)", "Q24: [603, 638)",
-         "Q20: [534, 568)", "Q25: [638, 640)", "Q20: [534, 568)", "Q23: [592, 603)",
-         "Q12: [373, 385)", "Q27: [648, 748)", "Q29: [772, 835)", "Q6: [206, 241)",
-         "Q34: [933, 947)", "Q16: [430, 442)", "Q26: [640, 648)", "Q15: [406, 430)",
-         "Q12: [373, 385)", "Q26: [640, 648)", "Q19: [496, 534)", "Q4: [133, 182)",
-         "Q34: [933, 947)", "Q31: [869, 887)", "Q10: [323, 354)", "Q21: [568, 589)",
-         "Q4: [133, 182)", "Q7: [241, 280)", "Q35: [947, 965)", "Q14: [387, 406)",
-         "Q18: [474, 496)", "Q34: [933, 947)", "Q20: [534, 568)", "Q22: [589, 592)",
-         "Q33: [923, 933)", "Q10: [323, 354)", "Q13: [385, 387)", "Q1: [23, 76)",
-         "Q36: [965, 980]", "Q2: [76, 101)", "Q23: [592, 603)", "Q6: [206, 241)",
-         "Q1: [23, 76)", "Q10: [323, 354)", "Q4: [133, 182)", "Q8: [280, 312)"]
-
-    @test cut([0, 1, 1, 1, 1], 2) ==
-        ["Q1: [0, 1)", "Q2: [1, 1]", "Q2: [1, 1]", "Q2: [1, 1]", "Q2: [1, 1]"]
-
-    @test cut([1, 1, 1, 1, 2], 2) ==
-        ["Q1: [1, 2)", "Q1: [1, 2)", "Q1: [1, 2)", "Q1: [1, 2)", "Q2: [2, 2]"]
+@testset "cut when quantile falls exactly on a data value" begin
+    x = cut([11, 14, 43, 54, 54, 56, 73, 79, 84, 84], 3)
+    @test x ==
+    ["Q1: [11, 54)", "Q1: [11, 54)", "Q1: [11, 54)",
+     "Q2: [54, 73)", "Q2: [54, 73)", "Q2: [54, 73)",
+     "Q3: [73, 84]", "Q3: [73, 84]", "Q3: [73, 84]", "Q3: [73, 84]"]
+    @test levels(x) == ["Q1: [11, 54)", "Q2: [54, 73)", "Q3: [73, 84]"]
 end
 
 end