Returns the object in enum that gives the maximum value from the given block.
If no block is given, an enumerator is returned instead.
a = %w(albatross dog horse) a.max_by { |x| x.length } #=> "albatross"
If the n argument is given, maximum n elements are returned as an array. These n elements are sorted by the value from the given block, in descending order.
a = %w[albatross dog horse] a.max_by(2) {|x| x.length } #=> ["albatross", "horse"]
enum.max_by(n) can be used to implement weighted random sampling. Following example implements and use Enumerable#wsample.
module Enumerable # 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) 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 #=> 20000 h = a.group_by {|x| x } -10.upto(10) {|x| puts "*" * (h[x].length/30.0).to_i if h[x] } #=> * # *** # ****** # *********** # ****************** # ***************************** # ***************************************** # **************************************************** # *************************************************************** # ******************************************************************** # *********************************************************************** # *********************************************************************** # ************************************************************** # **************************************************** # *************************************** # *************************** # ****************** # *********** # ******* # *** # *
Returns one of the following:
The maximum-valued element from self.
A new Array of maximum-valued elements selected from self.
When no block is given, each element in self must respond to method <=> with an Integer.
With no argument and no block, returns the element in self having the maximum value per method <=>:
[0, 1, 2].max # => 2
With an argument Integer n and no block, returns a new Array with at most n elements, in descending order per method <=>:
[0, 1, 2, 3].max(3) # => [3, 2, 1] [0, 1, 2, 3].max(6) # => [3, 2, 1]
When a block is given, the block must return an Integer.
With a block and no argument, calls the block self.size-1 times to compare elements; returns the element having the maximum value per the block:
['0', '00', '000'].max {|a, b| a.size <=> b.size } # => "000"
With an argument n and a block, returns a new Array with at most n elements, in descending order per the block:
['0', '00', '000'].max(2) {|a, b| a.size <=> b.size } # => ["000", "00"]
Returns the maximum value in the range, or an array of maximum values in the range if given an Integer argument.
For inclusive ranges with an end, the maximum value of the range is the same as the end of the range.
If an argument or block is given, or self is an exclusive, non-numeric range, calls Enumerable#max (via super) with the argument and/or block to get the maximum values, unless self is a beginless range, in which case it raises a RangeError.
If self is an exclusive, integer range (both start and end of the range are integers), and no arguments or block are provided, returns last value in the range (1 before the end). Otherwise, if self is an exclusive, numeric range, raises a TypeError.
Returns nil if the begin value of the range larger than the end value. Returns nil if the begin value of an exclusive range is equal to the end value. Raises a RangeError if called on an endless range.
Examples:
(10..20).max #=> 20 (10..20).max(2) #=> [20, 19] (10...20).max #=> 19 (10...20).max(2) #=> [19, 18] (10...20).max{|x, y| -x <=> -y } #=> 10 (10...20).max(2){|x, y| -x <=> -y } #=> [10, 11]
Returns the maximum size of the queue.
Returns the object in enum with the maximum value. The first form assumes all objects implement <=>; the second uses the block to return a <=> b.
a = %w(albatross dog horse) a.max #=> "horse" a.max { |a, b| a.length <=> b.length } #=> "albatross"
If the n argument is given, maximum n elements are returned as an array, sorted in descending order.
a = %w[albatross dog horse] a.max(2) #=> ["horse", "dog"] a.max(2) {|a, b| a.length <=> b.length } #=> ["albatross", "horse"] [5, 1, 3, 4, 2].max(3) #=> [5, 4, 3]
Maximum number of times to retry an idempotent request in case of Net::ReadTimeout, IOError, EOFError, Errno::ECONNRESET, Errno::ECONNABORTED, Errno::EPIPE, OpenSSL::SSL::SSLError, Timeout::Error. Should be a non-negative integer number. Zero means no retries. The default value is 1.
Returns the max number of flags interned to symbols.
Sets the max number of flags interned to symbols.
Sets the upper bound of the supported SSL/TLS protocol version. See min_version= for the possible values.
Returns a two element array containing the objects in enum that correspond to the minimum and maximum values respectively from the given block.
If no block is given, an enumerator is returned instead.
a = %w(albatross dog horse) a.minmax_by { |x| x.length } #=> ["dog", "albatross"]
This integer returns the maximum level of data structure nesting in the generated JSON, max_nesting = 0 if no maximum is checked.
This sets the maximum level of data structure nesting in the generated JSON to the integer depth, max_nesting = 0 if no maximum should be checked.
Sorts enum using a set of keys generated by mapping the values in enum through the given block.
The result is not guaranteed to be stable. When two keys are equal, the order of the corresponding elements is unpredictable.
If no block is given, an enumerator is returned instead.
%w{apple pear fig}.sort_by { |word| word.length } #=> ["fig", "pear", "apple"]
The current implementation of sort_by generates an array of tuples containing the original collection element and the mapped value. This makes sort_by fairly expensive when the keysets are simple.
require 'benchmark' a = (1..100000).map { rand(100000) } Benchmark.bm(10) do |b| b.report("Sort") { a.sort } b.report("Sort by") { a.sort_by { |a| a } } end
produces:
user system total real Sort 0.180000 0.000000 0.180000 ( 0.175469) Sort by 1.980000 0.040000 2.020000 ( 2.013586)
However, consider the case where comparing the keys is a non-trivial operation. The following code sorts some files on modification time using the basic sort method.
files = Dir["*"] sorted = files.sort { |a, b| File.new(a).mtime <=> File.new(b).mtime } sorted #=> ["mon", "tues", "wed", "thurs"]
This sort is inefficient: it generates two new File objects during every comparison. A slightly better technique is to use the Kernel#test method to generate the modification times directly.
files = Dir["*"] sorted = files.sort { |a, b| test(?M, a) <=> test(?M, b) } sorted #=> ["mon", "tues", "wed", "thurs"]
This still generates many unnecessary Time objects. A more efficient technique is to cache the sort keys (modification times in this case) before the sort. Perl users often call this approach a Schwartzian transform, after Randal Schwartz. We construct a temporary array, where each element is an array containing our sort key along with the filename. We sort this array, and then extract the filename from the result.
sorted = Dir["*"].collect { |f| [test(?M, f), f] }.sort.collect { |f| f[1] } sorted #=> ["mon", "tues", "wed", "thurs"]
This is exactly what sort_by does internally.
sorted = Dir["*"].sort_by { |f| test(?M, f) } sorted #=> ["mon", "tues", "wed", "thurs"]
To produce the reverse of a specific order, the following can be used:
ary.sort_by { ... }.reverse!
Groups the collection by result of the block. Returns a hash where the keys are the evaluated result from the block and the values are arrays of elements in the collection that correspond to the key.
If no block is given an enumerator is returned.
(1..6).group_by { |i| i%3 } #=> {0=>[3, 6], 1=>[1, 4], 2=>[2, 5]}
Returns the object in enum that gives the minimum value from the given block.
If no block is given, an enumerator is returned instead.
a = %w(albatross dog horse) a.min_by { |x| x.length } #=> "dog"
If the n argument is given, minimum n elements are returned as an array. These n elements are sorted by the value from the given block.
a = %w[albatross dog horse] p a.min_by(2) {|x| x.length } #=> ["dog", "horse"]
Makes the set compare its elements by their identity and returns self. This method may not be supported by all subclasses of Set.
Returns true if the set will compare its elements by their identity. Also see Set#compare_by_identity.
Sets self to consider only identity in comparing keys; two keys are considered the same only if they are the same object; returns self.
By default, these two object are considered to be the same key, so s1 will overwrite s0:
s0 = 'x' s1 = 'x' h = {} h.compare_by_identity? # => false h[s0] = 0 h[s1] = 1 h # => {"x"=>1}
After calling #compare_by_identity, the keys are considered to be different, and therefore do not overwrite each other:
h = {} h.compare_by_identity # => {} h.compare_by_identity? # => true h[s0] = 0 h[s1] = 1 h # => {"x"=>0, "x"=>1}
Returns true if compare_by_identity has been called, false otherwise.
Fetches the engine as specified by the id String.
OpenSSL::Engine.by_id("openssl")
=> #<OpenSSL::Engine id="openssl" name="Software engine support">
See OpenSSL::Engine.engines for the currently loaded engines.
Returns a duplicate table object, in column mode. This is handy for chaining in a single call without changing the table mode, but be aware that this method can consume a fair amount of memory for bigger data sets.
This method returns the duplicate table for chaining. Don’t chain destructive methods (like []=()) this way though, since you are working with a duplicate.
Switches the mode of this table to column mode. All calls to indexing and iteration methods will work with columns until the mode is changed again.
This method returns the table and is safe to chain.
Returns a duplicate table object, in row mode. This is handy for chaining in a single call without changing the table mode, but be aware that this method can consume a fair amount of memory for bigger data sets.
This method returns the duplicate table for chaining. Don’t chain destructive methods (like []=()) this way though, since you are working with a duplicate.