Results for: "match"

if /foo/ then end

^^^^^

Represents the use of the modifier ‘in` operator.

foo in bar
^^^^^^^^^^

Represents a regular expression literal used in the predicate of a conditional to implicitly match against the last line read by an IO object.

if /foo/i then end
   ^^^^^^

Represents the use of the ‘=>` operator.

foo => bar
^^^^^^^^^^

Represents writing local variables using a regular expression match with named capture groups.

/(?<foo>bar)/ =~ baz
^^^^^^^^^^^^^^^^^^^^

foo in bar ^^^^^^^^^^

foo in bar ^^^^^^^^^^

if /foo #{bar}/ then end

^^^^^^^^^^^^

case foo; in bar; end ^^^^^^^^^^^^^^^^^^^^^

foo => bar ^^^^^^^^^^

/(?<foo>foo)/ =~ bar ^^^^^^^^^^^^^^^^^^^^

case foo; in bar; end ^^^^^^^^^^^^^^^^^^^^^

foo => bar ^^^^^^^^^^

/(?<foo>foo)/ =~ bar ^^^^^^^^^^^^^^^^^^^^

if /foo/ then end

^^^^^

if /foo/ then end

^^^^^

Raised when attempting to convert special float values (in particular Infinity or NaN) to numerical classes which don’t support them.

Float::INFINITY.to_r   #=> FloatDomainError: Infinity

The Benchmark module provides methods to measure and report the time used to execute Ruby code.

• Measure the time to construct the string given by the expression "a"*1_000_000_000:

  require 'benchmark'
  
  puts Benchmark.measure { "a"*1_000_000_000 }
  

  On my machine (OSX 10.8.3 on i5 1.7 GHz) this generates:

  0.350000   0.400000   0.750000 (  0.835234)

  This report shows the user CPU time, system CPU time, the sum of the user and system CPU times, and the elapsed real time. The unit of time is seconds.

• Do some experiments sequentially using the bm method:

  require 'benchmark'
  
  n = 5000000
  Benchmark.bm do |x|
    x.report { for i in 1..n; a = "1"; end }
    x.report { n.times do   ; a = "1"; end }
    x.report { 1.upto(n) do ; a = "1"; end }
  end
  

  The result:

      user     system      total        real
  1.010000   0.000000   1.010000 (  1.014479)
  1.000000   0.000000   1.000000 (  0.998261)
  0.980000   0.000000   0.980000 (  0.981335)

• Continuing the previous example, put a label in each report:

  require 'benchmark'
  
  n = 5000000
  Benchmark.bm(7) do |x|
    x.report("for:")   { for i in 1..n; a = "1"; end }
    x.report("times:") { n.times do   ; a = "1"; end }
    x.report("upto:")  { 1.upto(n) do ; a = "1"; end }
  end
  

The result:

              user     system      total        real
for:      1.010000   0.000000   1.010000 (  1.015688)
times:    1.000000   0.000000   1.000000 (  1.003611)
upto:     1.030000   0.000000   1.030000 (  1.028098)

• The times for some benchmarks depend on the order in which items are run. These differences are due to the cost of memory allocation and garbage collection. To avoid these discrepancies, the bmbm method is provided. For example, to compare ways to sort an array of floats:

  require 'benchmark'
  
  array = (1..1000000).map { rand }
  
  Benchmark.bmbm do |x|
    x.report("sort!") { array.dup.sort! }
    x.report("sort")  { array.dup.sort  }
  end
  

  The result:

  Rehearsal -----------------------------------------
  sort!   1.490000   0.010000   1.500000 (  1.490520)
  sort    1.460000   0.000000   1.460000 (  1.463025)
  -------------------------------- total: 2.960000sec
  
              user     system      total        real
  sort!   1.460000   0.000000   1.460000 (  1.460465)
  sort    1.450000   0.010000   1.460000 (  1.448327)

• Report statistics of sequential experiments with unique labels, using the benchmark method:

  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
  

  The result:

               user     system      total        real
  for:      0.950000   0.000000   0.950000 (  0.952039)
  times:    0.980000   0.000000   0.980000 (  0.984938)
  upto:     0.950000   0.000000   0.950000 (  0.946787)
  >total:   2.880000   0.000000   2.880000 (  2.883764)
  >avg:     0.960000   0.000000   0.960000 (  0.961255)

mkmf.rb is used by Ruby C extensions to generate a Makefile which will correctly compile and link the C extension to Ruby and a third-party library.

Module Math provides methods for basic trigonometric, logarithmic, and transcendental functions, and for extracting roots.

You can write its constants and method calls thus:

Math::PI      # => 3.141592653589793
Math::E       # => 2.718281828459045
Math.sin(0.0) # => 0.0
Math.cos(0.0) # => 1.0

If you include module Math, you can write simpler forms:

include Math
PI       # => 3.141592653589793
E        # => 2.718281828459045
sin(0.0) # => 0.0
cos(0.0) # => 1.0

For simplicity, the examples here assume:

include Math
INFINITY = Float::INFINITY

The domains and ranges for the methods are denoted by open or closed intervals, using, respectively, parentheses or square brackets:

• An open interval does not include the endpoints:

  (-INFINITY, INFINITY)

• A closed interval includes the endpoints:

  [-1.0, 1.0]
  

• A half-open interval includes one endpoint, but not the other:

  [1.0, INFINITY)

Many values returned by Math methods are numerical approximations. This is because many such values are, in mathematics, of infinite precision, while in numerical computation the precision is finite.

Thus, in mathematics, cos(π/2) is exactly zero, but in our computation cos(PI/2) is a number very close to zero:

cos(PI/2) # => 6.123031769111886e-17

For very large and very small returned values, we have added formatted numbers for clarity:

tan(PI/2)  # => 1.633123935319537e+16   # 16331239353195370.0
tan(PI)    # => -1.2246467991473532e-16 # -0.0000000000000001

See class Float for the constants that affect Ruby’s floating-point arithmetic.

What’s Here

Trigonometric Functions

• ::cos: Returns the cosine of the given argument.

• ::sin: Returns the sine of the given argument.

• ::tan: Returns the tangent of the given argument.

Inverse Trigonometric Functions

• ::acos: Returns the arc cosine of the given argument.

• ::asin: Returns the arc sine of the given argument.

• ::atan: Returns the arc tangent of the given argument.

• ::atan2: Returns the arg tangent of two given arguments.

Hyperbolic Trigonometric Functions

• ::cosh: Returns the hyperbolic cosine of the given argument.

• ::sinh: Returns the hyperbolic sine of the given argument.

• ::tanh: Returns the hyperbolic tangent of the given argument.

Inverse Hyperbolic Trigonometric Functions

• ::acosh: Returns the inverse hyperbolic cosine of the given argument.

• ::asinh: Returns the inverse hyperbolic sine of the given argument.

• ::atanh: Returns the inverse hyperbolic tangent of the given argument.

Exponentiation and Logarithmic Functions

• ::exp: Returns the value of a given value raised to a given power.

• ::log: Returns the logarithm of a given value in a given base.

• ::log10: Returns the base 10 logarithm of the given argument.

• ::log2: Returns the base 2 logarithm of the given argument.

Fraction and Exponent Functions

• ::frexp: Returns the fraction and exponent of the given argument.

• ::ldexp: Returns the value for a given fraction and exponent.

Root Functions

• ::cbrt: Returns the cube root of the given argument.

• ::sqrt: Returns the square root of the given argument.

Error Functions

• ::erf: Returns the value of the Gauss error function for the given argument.

• ::erfc: Returns the value of the complementary error function for the given argument.

Gamma Functions

• ::gamma: Returns the value of the gamma function for the given argument.

• ::lgamma: Returns the value of the logarithmic gamma function for the given argument.

Hypotenuse Function

• ::hypot: Returns sqrt(a**2 + b**2) for the given a and b.

Represents a regular expression literal that contains interpolation that is being used in the predicate of a conditional to implicitly match against the last line read by an IO object.

if /foo #{bar} baz/ then end
   ^^^^^^^^^^^^^^^^

Generated when trying to lookup a gem to indicate that the gem was found, but that it isn’t usable on the current platform.

fetch and install read these and report them to the user to aid in figuring out why a gem couldn’t be installed.

Represents the use of a case statement for pattern matching.

case true
in false
end
^^^^^^^^^