From: davidegrayson@...
Date: 2014-10-07T03:20:04+00:00
Subject: [ruby-core:65452] [ruby-trunk - Feature #8887] min(n), max(n),	min_by(n), max_by(n)

Issue #8887 has been updated by David Grayson.


Hello.  I think the Ruby team should reconsider the ordering of the array returned by `max` and `max_by` when the `n` argument is provided.  It makes much more sense to me that it would be sorted in descending order, meaning that the most extreme/special element would be first.  For example, I would expect `max` to behave like this:

    [1, 2, 10, 22, 23].max(3)  # => [23, 22, 10]

It seems that min/min_by and max/max_by should be mirrors of each other.  For example, I would expect that `max_by(n) { |x| x.foo }` would be equivalent to `min_by(n) { |x| -x.foo }`, assuming that `foo` returns a number.

That leaves us with two choices for the sorting: put the most extreme element first, or put the most extreme element last.  I think putting the most extreme element first makes the most sense.  Whenever I see any list of top-ranked items, the highest-ranked item is usually first.  Here are some examples from the internet: http://imgur.com/a/MPsJl

I looked around on StackOverflow.com for Ruby users who might benefit from the new argument to min/min_by/max/max_by.  Almost everyone asking a question about it wanted to use something like `max_by` and wanted to have the most extreme element be listed first:

* http://stackoverflow.com/questions/19804696
* http://stackoverflow.com/questions/11094874
* http://stackoverflow.com/questions/9390444

However, I should note that in one case, the questioner wanted the order of the original enumerable to be preserved (http://stackoverflow.com/questions/9459447), and in another case they didn't specify (http://stackoverflow.com/questions/12241165).  I didn't find anyone who wanted the most extreme element to be last.

I also looked for similar features in other programming languages.  The closest thing I found was Python's `heapq.nlargest` method, which does return the most extreme element first:

https://docs.python.org/3/library/heapq.html#heapq.nlargest

In SQL, if you are making a query to get the top 10 rows, I think you must do something like this, which puts the most extreme row first:

    select * from players order by score desc limit 10

In conclusion, I think it is more natural for the `max` and `max_by` methods to return arrays with the most extreme element first.  I hope the Ruby team will do this before Ruby 2.2.0 is released, since it will be hard to change it later without breaking a lot of people's code.

--David Grayson

P.S. Some other Ruby developers I know here in Las Vegas have agreed with this letter and wanted their names to be included:

* Jason Arhart
* Paul Grayson

----------------------------------------
Feature #8887: min(n), max(n), min_by(n), max_by(n)
https://bugs.ruby-lang.org/issues/8887#change-49236

* Author: Akira Tanaka
* Status: Closed
* Priority: Normal
* Assignee: Akira Tanaka
* Category: core
* Target version: 
----------------------------------------
How about adding an optional argument, n, for Enumerable#{min,max,min_by,max_by} to
return minimum/maximum n elements as an array.

Example:
* [6, 0, 3, 3, 8, 3, 5, 0, 6].min(4) #=> [0, 0, 3, 3]
* [6, 0, 3, 3, 8, 3, 5, 0, 6].max(4) #=> [5, 6, 6, 8]
* [6, 0, 3, 3, 8, 3, 5, 0, 6].min_by(4) {|v| (v-5)**2 } #=> [5, 6, 6, 3]
* [6, 0, 3, 3, 8, 3, 5, 0, 6].max_by(4) {|v| (v-5)**2 } #=> [3, 8, 0, 0]

These methods are similar to sort follows first or last.

* e.min(n) is similar to e.sort.first(n)
* e.max(n) is similar to e.sort.last(n)
* e.min_by(n) {...} is similar to e.sort_by {...}.first(n)
* e.max_by(n) {...} is similar to e.sort_by {...}.last(n)

However e.min(n), e.max(n), e.min_by(n), e.max_by(n) are
less memory consuming and can be faster.
They use memory proportional to n, not e.
They doesn't sort whole e. 

I feel their use is not rare.
I found several use after searching.

[ruby-talk:123508], [ruby-list:40939], [ruby-talk:273980]
http://d.hatena.ne.jp/mjh/20101024/1287901875
http://stackoverflow.com/questions/11094874/get-top-n-elements-from-ruby-array-of-hash-values
http://www.math.kobe-u.ac.jp/~kodama/tips-ruby-sized_pqueue.html
https://bitbucket.org/sterlingcamden/topn

Also, e.max(n) can be used to implement weighted random sampling.

Pavlos S. Efraimidis, Paul G. Spirakis
Weighted random sampling with a reservoir
Information Processing Letters
Volume 97, Issue 5 (16 March 2006)

```
  % ./ruby -e '
  module Enumerable
    def wsample(n)
      self.max_by(n) {|v| rand ** (1.0/yield(v)) }
    end
  end
  e = (-20..20).to_a*10000
  a = e.wsample(20000) {|x|
    Math.exp(-(x/5.0)**2) # normal distribution
  }
  # a is 20000 samples from e.
  p a.length
  h = a.group_by {|x| x }
  -10.upto(10) {|x| puts "*" * (h[x].length/30.0).to_i if h[x] }
  '
  20000
  *
  ***
  ******
  ***********
  ******************
  *****************************
  *****************************************
  ****************************************************
  ***************************************************************
  ********************************************************************
  ***********************************************************************
  ***********************************************************************
  **************************************************************
  ****************************************************
  ***************************************
  ***************************
  ******************
  ***********
  *******
  ***
  *
```

Any comments?


---Files--------------------------------
min-n-and-max-n.patch (15.2 KB)
maxn.pdf (20.3 KB)


-- 
https://bugs.ruby-lang.org/