Issue #20226 has been updated by nobu (Nobuyoshi Nakada). `sort` family methods do not guarantee stable sort. That means the result order of the same value elements is not affected by the original order of those elements. ---------------------------------------- Bug #20226: Inconsistent Sort results on 3.3.0 compared to previous versions https://bugs.ruby-lang.org/issues/20226#change-106515 * Author: omerby (Omer Ben Yosef) * Status: Open * Priority: Normal * ruby -v: 3.3.0 * Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- Try this code block: ``` [-0.9, -0.88, -0.85, -0.83, -0.81, -0.79, -0.77, -0.75, -0.73, -0.71, -0.69, -0.67, -0.65, -0.63, -0.6, -0.58, -0.56, -0.54, -0.52, -0.5, -0.48, -0.46, -0.44, -0.42, -0.4, -0.38, -0.35, -0.33, -0.31, -0.29, -0.27, -0.25, -0.23, -0.21, -0.19, -0.17, -0.15, -0.13, -0.1, -0.08, -0.06, -0.04, -0.02, 0.0, 0.02, 0.0, 0.02].sort_by(&:abs) ``` The end result should be the numbers absolute sorted, look at the last 5 numbers of this, the end result of them should be `[0.0, 0.0, -0.02, 0.02, 0.02...]` maintaining the original order, and this behavior is what we see on ruby 3.2.0, however on ruby 3.3.0 the end result will be `[0.0, 0.0, 0.02, 0.02, -0.02...]` This is also inconsistent, as `[-0.02, 0.0, 0.02, 0.0, 0.02].sort_by(&:abs)` will actually provide the expected result. Again, the main issue for us is the difference between 3.3.0 and previous versions of ruby. -- https://bugs.ruby-lang.org/

Issue #20226 has been updated by Eregon (Benoit Daloze). When was `sort`/`sort_by` changed to no longer be stable? I don't remind any ticket about it or NEWS entry. IMO it's a pretty big change to make it non-stable when it has been stable for so long. Especially for a high-level language like Ruby, where I'd think most users do not expect such low-level & error-prone issues to arise. ---------------------------------------- Bug #20226: Inconsistent Sort results on 3.3.0 compared to previous versions https://bugs.ruby-lang.org/issues/20226#change-106517 * Author: omerby (Omer Ben Yosef) * Status: Open * Priority: Normal * ruby -v: 3.3.0 * Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- Try this code block: ``` [-0.9, -0.88, -0.85, -0.83, -0.81, -0.79, -0.77, -0.75, -0.73, -0.71, -0.69, -0.67, -0.65, -0.63, -0.6, -0.58, -0.56, -0.54, -0.52, -0.5, -0.48, -0.46, -0.44, -0.42, -0.4, -0.38, -0.35, -0.33, -0.31, -0.29, -0.27, -0.25, -0.23, -0.21, -0.19, -0.17, -0.15, -0.13, -0.1, -0.08, -0.06, -0.04, -0.02, 0.0, 0.02, 0.0, 0.02].sort_by(&:abs) ``` The end result should be the numbers absolute sorted, look at the last 5 numbers of this, the end result of them should be `[0.0, 0.0, -0.02, 0.02, 0.02...]` maintaining the original order, and this behavior is what we see on ruby 3.2.0, however on ruby 3.3.0 the end result will be `[0.0, 0.0, 0.02, 0.02, -0.02...]` This is also inconsistent, as `[-0.02, 0.0, 0.02, 0.0, 0.02].sort_by(&:abs)` will actually provide the expected result. Again, the main issue for us is the difference between 3.3.0 and previous versions of ruby. -- https://bugs.ruby-lang.org/

Issue #20226 has been updated by ufuk (Ufuk Kayserilioglu). Here is the previous discussion from 15 years ago: https://bugs.ruby-lang.org/issues/1089 It might be about time to revisit the performance impact of a stable sort, imo, but that's not the discussion on this ticket. ---------------------------------------- Bug #20226: Inconsistent Sort results on 3.3.0 compared to previous versions https://bugs.ruby-lang.org/issues/20226#change-106519 * Author: omerby (Omer Ben Yosef) * Status: Open * Priority: Normal * ruby -v: 3.3.0 * Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- Try this code block: ``` [-0.9, -0.88, -0.85, -0.83, -0.81, -0.79, -0.77, -0.75, -0.73, -0.71, -0.69, -0.67, -0.65, -0.63, -0.6, -0.58, -0.56, -0.54, -0.52, -0.5, -0.48, -0.46, -0.44, -0.42, -0.4, -0.38, -0.35, -0.33, -0.31, -0.29, -0.27, -0.25, -0.23, -0.21, -0.19, -0.17, -0.15, -0.13, -0.1, -0.08, -0.06, -0.04, -0.02, 0.0, 0.02, 0.0, 0.02].sort_by(&:abs) ``` The end result should be the numbers absolute sorted, look at the last 5 numbers of this, the end result of them should be `[0.0, 0.0, -0.02, 0.02, 0.02...]` maintaining the original order, and this behavior is what we see on ruby 3.2.0, however on ruby 3.3.0 the end result will be `[0.0, 0.0, 0.02, 0.02, -0.02...]` This is also inconsistent, as `[-0.02, 0.0, 0.02, 0.0, 0.02].sort_by(&:abs)` will actually provide the expected result. Again, the main issue for us is the difference between 3.3.0 and previous versions of ruby. -- https://bugs.ruby-lang.org/

Issue #20226 has been updated by ufuk (Ufuk Kayserilioglu). `Enumerable#sort_by` was also documented to not be stable in 3.2 (and previous versions): https://ruby-doc.org/3.2.3/Enumerable.html#method-i-sort_by What might have changed (this is a layman's guess since I don't know the internals of Ruby sorting that well) is which sort routine Ruby uses from the OS/libc by default, which might change the behaviour of the resulting sort. Since Ruby provides no guarantees of stable sorting, this is not a regression, despite what specific platform sort routines might provide. ---------------------------------------- Bug #20226: Inconsistent Sort results on 3.3.0 compared to previous versions https://bugs.ruby-lang.org/issues/20226#change-106521 * Author: omerby (Omer Ben Yosef) * Status: Open * Priority: Normal * ruby -v: 3.3.0 * Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- Try this code block: ``` [-0.9, -0.88, -0.85, -0.83, -0.81, -0.79, -0.77, -0.75, -0.73, -0.71, -0.69, -0.67, -0.65, -0.63, -0.6, -0.58, -0.56, -0.54, -0.52, -0.5, -0.48, -0.46, -0.44, -0.42, -0.4, -0.38, -0.35, -0.33, -0.31, -0.29, -0.27, -0.25, -0.23, -0.21, -0.19, -0.17, -0.15, -0.13, -0.1, -0.08, -0.06, -0.04, -0.02, 0.0, 0.02, 0.0, 0.02].sort_by(&:abs) ``` The end result should be the numbers absolute sorted, look at the last 5 numbers of this, the end result of them should be `[0.0, 0.0, -0.02, 0.02, 0.02...]` maintaining the original order, and this behavior is what we see on ruby 3.2.0, however on ruby 3.3.0 the end result will be `[0.0, 0.0, 0.02, 0.02, -0.02...]` This is also inconsistent, as `[-0.02, 0.0, 0.02, 0.0, 0.02].sort_by(&:abs)` will actually provide the expected result. Again, the main issue for us is the difference between 3.3.0 and previous versions of ruby. -- https://bugs.ruby-lang.org/

Issue #20226 has been updated by ufuk (Ufuk Kayserilioglu). Regardless of any individual impressions, Ruby never made any stability guarantees for sorting. It was always explicit that sorting MAY BE unstable. This is because Ruby delegates the actual sorting to the efficient sorting routines provided by the platform in most cases, and those routines are free to handle sorting with whichever algorithm would be the most efficient for the input. This means that a sort that is always stable on macOS could show unstable results on Linux, for example, or vice versa. So, regardless of what you are observing, Ruby makes no guarantees about the stability of sorting and that has always been the case. I've linked to a conversation from 15 years ago about making the sort stable, which was rejected at the time. If you would like to propose a path forward for stable sorting guarantees in Ruby, please open a Feature ticket with the proposed implementation and performance implications. ---------------------------------------- Bug #20226: Inconsistent Sort results on 3.3.0 compared to previous versions https://bugs.ruby-lang.org/issues/20226#change-106526 * Author: omerby (Omer Ben Yosef) * Status: Open * Priority: Normal * ruby -v: 3.3.0 * Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- Try this code block: ``` [-0.9, -0.88, -0.85, -0.83, -0.81, -0.79, -0.77, -0.75, -0.73, -0.71, -0.69, -0.67, -0.65, -0.63, -0.6, -0.58, -0.56, -0.54, -0.52, -0.5, -0.48, -0.46, -0.44, -0.42, -0.4, -0.38, -0.35, -0.33, -0.31, -0.29, -0.27, -0.25, -0.23, -0.21, -0.19, -0.17, -0.15, -0.13, -0.1, -0.08, -0.06, -0.04, -0.02, 0.0, 0.02, 0.0, 0.02].sort_by(&:abs) ``` The end result should be the numbers absolute sorted, look at the last 5 numbers of this, the end result of them should be `[0.0, 0.0, -0.02, 0.02, 0.02...]` maintaining the original order, and this behavior is what we see on ruby 3.2.0, however on ruby 3.3.0 the end result will be `[0.0, 0.0, 0.02, 0.02, -0.02...]` This is also inconsistent, as `[-0.02, 0.0, 0.02, 0.0, 0.02].sort_by(&:abs)` will actually provide the expected result. Again, the main issue for us is the difference between 3.3.0 and previous versions of ruby. -- https://bugs.ruby-lang.org/

Issue #20226 has been updated by Eregon (Benoit Daloze). I think that's a fair point, similar to e.g Set insertion ordering, even though that's not documented I'm pretty sure some Ruby code relies on it because it holds since a very long time. The key seems to be whether sort was in practice stable on some platform/OS (I don't know for sure). It'd be interesting to find out what exactly changed for 3.3.0. ---------------------------------------- Bug #20226: Inconsistent Sort results on 3.3.0 compared to previous versions https://bugs.ruby-lang.org/issues/20226#change-106530 * Author: omerby (Omer Ben Yosef) * Status: Open * Priority: Normal * ruby -v: 3.3.0 * Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- Try this code block: ``` [-0.9, -0.88, -0.85, -0.83, -0.81, -0.79, -0.77, -0.75, -0.73, -0.71, -0.69, -0.67, -0.65, -0.63, -0.6, -0.58, -0.56, -0.54, -0.52, -0.5, -0.48, -0.46, -0.44, -0.42, -0.4, -0.38, -0.35, -0.33, -0.31, -0.29, -0.27, -0.25, -0.23, -0.21, -0.19, -0.17, -0.15, -0.13, -0.1, -0.08, -0.06, -0.04, -0.02, 0.0, 0.02, 0.0, 0.02].sort_by(&:abs) ``` The end result should be the numbers absolute sorted, look at the last 5 numbers of this, the end result of them should be `[0.0, 0.0, -0.02, 0.02, 0.02...]` maintaining the original order, and this behavior is what we see on ruby 3.2.0, however on ruby 3.3.0 the end result will be `[0.0, 0.0, 0.02, 0.02, -0.02...]` This is also inconsistent, as `[-0.02, 0.0, 0.02, 0.0, 0.02].sort_by(&:abs)` will actually provide the expected result. Again, the main issue for us is the difference between 3.3.0 and previous versions of ruby. -- https://bugs.ruby-lang.org/

Issue #20226 has been updated by alanwu (Alan Wu). Ah, until recently, glibc's `qsort` was actually a stable merge sort most of the time, which is why Ruby's sort felt stable on Linux. https://sourceware.org/git/?p=glibc.git;a=commitdiff;h=03bf8357e8291857a435… https://lists.libvirt.org/archives/list/devel@lists.libvirt.org/thread/GBTH… ---------------------------------------- Bug #20226: Inconsistent Sort results on 3.3.0 compared to previous versions https://bugs.ruby-lang.org/issues/20226#change-106550 * Author: omerby (Omer Ben Yosef) * Status: Open * Priority: Normal * ruby -v: 3.3.0 * Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN ---------------------------------------- Try this code block: ``` [-0.9, -0.88, -0.85, -0.83, -0.81, -0.79, -0.77, -0.75, -0.73, -0.71, -0.69, -0.67, -0.65, -0.63, -0.6, -0.58, -0.56, -0.54, -0.52, -0.5, -0.48, -0.46, -0.44, -0.42, -0.4, -0.38, -0.35, -0.33, -0.31, -0.29, -0.27, -0.25, -0.23, -0.21, -0.19, -0.17, -0.15, -0.13, -0.1, -0.08, -0.06, -0.04, -0.02, 0.0, 0.02, 0.0, 0.02].sort_by(&:abs) ``` The end result should be the numbers absolute sorted, look at the last 5 numbers of this, the end result of them should be `[0.0, 0.0, -0.02, 0.02, 0.02...]` maintaining the original order, and this behavior is what we see on ruby 3.2.0, however on ruby 3.3.0 the end result will be `[0.0, 0.0, 0.02, 0.02, -0.02...]` This is also inconsistent, as `[-0.02, 0.0, 0.02, 0.0, 0.02].sort_by(&:abs)` will actually provide the expected result. Again, the main issue for us is the difference between 3.3.0 and previous versions of ruby. -- https://bugs.ruby-lang.org/