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 #{bar}/ then end
^^^^^^^^^^^^
if /foo #{bar}/ 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
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.
::cos: Returns the cosine of the given argument.
::sin: Returns the sine of the given argument.
::tan: Returns the tangent of the given argument.
::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.
::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.
::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.
::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.
::frexp: Returns the fraction and exponent of the given argument.
::ldexp: Returns the value for a given fraction and exponent.
::cbrt: Returns the cube root of the given argument.
::sqrt: Returns the square root of the given argument.
::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: Returns the value of the gamma function for the given argument.
::lgamma: Returns the value of the logarithmic gamma function for the given argument.
::hypot: Returns sqrt(a**2 + b**2) for the given a and b.
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.
Raised when a gem dependencies file specifies a ruby version that does not match the current version.
Response class for Non-Authoritative Information responses (status code 203).
The Non-Authoritative Information response indicates that the server is a transforming proxy (such as a Web accelerator) that received a 200 OK response from its origin, and is returning a modified version of the origin’s response.
References:
A Float object represents a sometimes-inexact real number using the native architecture’s double-precision floating point representation.
Floating point has a different arithmetic and is an inexact number. So you should know its esoteric system. See following:
You can create a Float object explicitly with:
A floating-point literal.
You can convert certain objects to Floats with:
First, what’s elsewhere. Class Float:
Inherits from class Numeric and class Object.
Includes module Comparable.
Here, class Float provides methods for:
finite?: Returns whether self is finite.
hash: Returns the integer hash code for self.
infinite?: Returns whether self is infinite.
nan?: Returns whether self is a NaN (not-a-number).
<: Returns whether self is less than the given value.
<=: Returns whether self is less than or equal to the given value.
<=>: Returns a number indicating whether self is less than, equal to, or greater than the given value.
== (aliased as === and eql?): Returns whether self is equal to the given value.
>: Returns whether self is greater than the given value.
>=: Returns whether self is greater than or equal to the given value.
*: Returns the product of self and the given value.
**: Returns the value of self raised to the power of the given value.
+: Returns the sum of self and the given value.
-: Returns the difference of self and the given value.
/: Returns the quotient of self and the given value.
ceil: Returns the smallest number greater than or equal to self.
coerce: Returns a 2-element array containing the given value converted to a Float and self
divmod: Returns a 2-element array containing the quotient and remainder results of dividing self by the given value.
fdiv: Returns the Float result of dividing self by the given value.
floor: Returns the greatest number smaller than or equal to self.
next_float: Returns the next-larger representable Float.
prev_float: Returns the next-smaller representable Float.
quo: Returns the quotient from dividing self by the given value.
round: Returns self rounded to the nearest value, to a given precision.
to_i (aliased as to_int): Returns self truncated to an Integer.
to_s (aliased as inspect): Returns a string containing the place-value representation of self in the given radix.
truncate: Returns self truncated to a given precision.
Continuation objects are generated by Kernel#callcc, after having +require+d continuation. They hold a return address and execution context, allowing a nonlocal return to the end of the callcc block from anywhere within a program. Continuations are somewhat analogous to a structured version of C’s setjmp/longjmp (although they contain more state, so you might consider them closer to threads).
For instance:
require "continuation" arr = [ "Freddie", "Herbie", "Ron", "Max", "Ringo" ] callcc{|cc| $cc = cc} puts(message = arr.shift) $cc.call unless message =~ /Max/
produces:
Freddie Herbie Ron Max
Also you can call callcc in other methods:
require "continuation" def g arr = [ "Freddie", "Herbie", "Ron", "Max", "Ringo" ] cc = callcc { |cc| cc } puts arr.shift return cc, arr.size end def f c, size = g c.call(c) if size > 1 end f
This (somewhat contrived) example allows the inner loop to abandon processing early:
require "continuation" callcc {|cont| for i in 0..4 print "#{i}: " for j in i*5...(i+1)*5 cont.call() if j == 17 printf "%3d", j end end } puts
produces:
0: 0 1 2 3 4 1: 5 6 7 8 9 2: 10 11 12 13 14 3: 15 16