# Results for: "max_by"

#### Enumerable#max_by

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] }
#=> *
#   ***
#   ******
#   ***********
#   ******************
#   *****************************
#   *****************************************
#   ****************************************************
#   ***************************************************************
#   ********************************************************************
#   ***********************************************************************
#   ***********************************************************************
#   **************************************************************
#   ****************************************************
#   ***************************************
#   ***************************
#   ******************
#   ***********
#   *******
#   ***
#   *
```

#### Array#max

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"]
```

#### Range#max

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]
```

#### SizedQueue#max

Returns the maximum size of the queue.

#### Enumerable#max

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]
```

#### Net::HTTP#max_retries=

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.

#### Racc::SymbolTable#nt_max

No documentation available

#### Net::IMAP::max_flag_count

Returns the max number of flags interned to symbols.

#### Net::IMAP::max_flag_count=

Sets the max number of flags interned to symbols.

#### OpenSSL::SSL::SSLContext#max_version=

Sets the upper bound of the supported SSL/TLS protocol version. See `min_version=` for the possible values.

#### Enumerable#minmax_by

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"]
```

#### JSON::Ext::Generator::State#max_nesting

This integer returns the maximum level of data structure nesting in the generated `JSON`, `max_nesting` = 0 if no maximum is checked.

#### JSON::Ext::Generator::State#max_nesting=

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.

#### Enumerable#sort_by

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!`

#### Enumerable#group_by

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]}
```

#### Enumerable#min_by

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"]
```

#### Set#compare_by_identity

Makes the set compare its elements by their identity and returns self. This method may not be supported by all subclasses of `Set`.

#### Set#compare_by_identity?

Returns true if the set will compare its elements by their identity. Also see `Set#compare_by_identity`.

#### Hash#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}
```

#### Hash#compare_by_identity?

Returns `true` if `compare_by_identity` has been called, `false` otherwise.

#### OptionParser#define_by_keywords

No documentation available

#### OpenSSL::Engine::by_id

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.

#### CSV::Table#by_col

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.

#### CSV::Table#by_col!

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.

#### CSV::Table#by_row

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.

Search took: 6ms  ·  Total Results: 498