Results for: "max_by"

Regexp#match?

Returns true or false to indicate whether the regexp is matched or not without updating $~ and other related variables. If the second parameter is present, it specifies the position in the string to begin the search.

/R.../.match?("Ruby")    # => true
/R.../.match?("Ruby", 1) # => false
/P.../.match?("Ruby")    # => false
$&                       # => nil

Set#map!

No documentation available

Symbol#match

Equivalent to self.to_s.match, including possible updates to global variables; see String#match.

Symbol#match?

Equivalent to sym.to_s.match?; see String#match.

Pathname#fnmatch

Return true if the receiver matches the given pattern.

See File.fnmatch.

Pathname#fnmatch?

Return true if the receiver matches the given pattern.

See File.fnmatch.

StringScanner#match?

Tests whether the given pattern is matched from the current scan pointer. Returns the length of the match, or nil. The scan pointer is not advanced.

s = StringScanner.new('test string')
p s.match?(/\w+/)   # -> 4
p s.match?(/\w+/)   # -> 4
p s.match?("test")  # -> 4
p s.match?(/\s+/)   # -> nil

StringScanner#matched?

Returns true if and only if the last match was successful.

s = StringScanner.new('test string')
s.match?(/\w+/)     # => 4
s.matched?          # => true
s.match?(/\d+/)     # => nil
s.matched?          # => false

StringScanner#matched

Returns the last matched string.

s = StringScanner.new('test string')
s.match?(/\w+/)     # -> 4
s.matched           # -> "test"

IPAddr#mask

Returns a new ipaddr built by masking IP address with the given prefixlen/netmask. (e.g. 8, 64, “255.255.255.0”, etc.)

IPAddr#netmask

Returns the netmask in string format e.g. 255.255.0.0

IPAddr#mask!

Set current netmask to given mask.

OptionParser#summarize

Puts option summary into to and returns to. Yields each line if a block is given.

to: Output destination, which must have method <<. Defaults to [].
width: Width of left side, defaults to @summary_width.
max: Maximum length allowed for left side, defaults to width - 1.
indent: Indentation, defaults to @summary_indent.

MatchData#match

Returns the matched substring corresponding to the given argument.

When non-negative argument n is given, returns the matched substring for the nth match:

m = /(.)(.)(\d+)(\d)(\w)?/.match("THX1138.")
# => #<MatchData "HX1138" 1:"H" 2:"X" 3:"113" 4:"8" 5:nil>
m.match(0) # => "HX1138"
m.match(4) # => "8"
m.match(5) # => nil

When string or symbol argument name is given, returns the matched substring for the given name:

m = /(?<foo>.)(.)(?<bar>.+)/.match("hoge")
# => #<MatchData "hoge" foo:"h" bar:"ge">
m.match('foo') # => "h"
m.match(:bar)  # => "ge"

PrettyPrint::format

This is a convenience method which is same as follows:

begin
  q = PrettyPrint.new(output, maxwidth, newline, &genspace)
  ...
  q.flush
  output
end

Ractor::main

returns main ractor

Thread::main

Returns the main thread.

Kernel#BigDecimal

Returns the BigDecimal converted from value with a precision of ndigits decimal digits.

When ndigits is less than the number of significant digits in the value, the result is rounded to that number of digits, according to the current rounding mode; see BigDecimal.mode.

When ndigits is 0, the number of digits to correctly represent a float number is determined automatically.

Returns value converted to a BigDecimal, depending on the type of value:

Integer, Float, Rational, Complex, or BigDecimal: converted directly:

# Integer, Complex, or BigDecimal value does not require ndigits; ignored if given.
BigDecimal(2)                     # => 0.2e1
BigDecimal(Complex(2, 0))         # => 0.2e1
BigDecimal(BigDecimal(2))         # => 0.2e1
# Float or Rational value requires ndigits.
BigDecimal(2.0, 0)                # => 0.2e1
BigDecimal(Rational(2, 1), 0)     # => 0.2e1

String: converted by parsing if it contains an integer or floating-point literal; leading and trailing whitespace is ignored:

# String does not require ndigits; ignored if given.
BigDecimal('2')     # => 0.2e1
BigDecimal('2.0')   # => 0.2e1
BigDecimal('0.2e1') # => 0.2e1
BigDecimal(' 2.0 ') # => 0.2e1

Other type that responds to method :to_str: first converted to a string, then converted to a BigDecimal, as above.
Other type:
- Raises an exception if keyword argument exception is true.
- Returns nil if keyword argument exception is false.

Raises an exception if value evaluates to a Float and digits is larger than Float::DIG + 1.

Kernel#format

Returns the string resulting from formatting objects into format_string.

For details on format_string, see Format Specifications.

Enumerable#map

Returns an array of objects returned by the block.

With a block given, calls the block with successive elements; returns an array of the objects returned by the block:

(0..4).map {|i| i*i }                               # => [0, 1, 4, 9, 16]
{foo: 0, bar: 1, baz: 2}.map {|key, value| value*2} # => [0, 2, 4]

With no block given, returns an Enumerator.

Fiddle::malloc

Allocate size bytes of memory and return the integer memory address for the allocated memory.

Syslog::mask

Returns the log priority mask in effect. The mask is not reset by opening or closing syslog.

Syslog::mask=

Sets the log priority mask. A method LOG_UPTO is defined to make it easier to set mask values. Example:

Syslog.mask = Syslog::LOG_UPTO(Syslog::LOG_ERR)

Alternatively, specific priorities can be selected and added together using binary OR. Example:

Syslog.mask = Syslog::LOG_MASK(Syslog::LOG_ERR) | Syslog::LOG_MASK(Syslog::LOG_CRIT)

The priority mask persists through calls to open() and close().

Benchmark#benchmark

Invokes the block with a Benchmark::Report object, which may be used to collect and report on the results of individual benchmark tests. Reserves label_width leading spaces for labels on each line. Prints caption at the top of the report, and uses format to format each line. (Note: caption must contain a terminating newline character, see the default Benchmark::Tms::CAPTION for an example.)

Returns an array of Benchmark::Tms objects.

If the block returns an array of Benchmark::Tms objects, these will be used to format additional lines of output. If labels parameter are given, these are used to label these extra lines.

Note: Other methods provide a simpler interface to this one, and are suitable for nearly all benchmarking requirements. See the examples in Benchmark, and the bm and bmbm methods.

Example:

require 'benchmark'
include Benchmark          # we need the CAPTION and FORMAT constants

n = 5000000
Benchmark.benchmark(CAPTION, 7, FORMAT, ">total:", ">avg:") do |x|
  tf = x.report("for:")   { for i in 1..n; a = "1"; end }
  tt = x.report("times:") { n.times do   ; a = "1"; end }
  tu = x.report("upto:")  { 1.upto(n) do ; a = "1"; end }
  [tf+tt+tu, (tf+tt+tu)/3]
end

Generates:

              user     system      total        real
for:      0.970000   0.000000   0.970000 (  0.970493)
times:    0.990000   0.000000   0.990000 (  0.989542)
upto:     0.970000   0.000000   0.970000 (  0.972854)
>total:   2.930000   0.000000   2.930000 (  2.932889)
>avg:     0.976667   0.000000   0.976667 (  0.977630)

Benchmark::benchmark