Returns true if float is 0.0.
Returns the largest number less than or equal to float in decimal digits (default 0 digits).
Precision may be negative. Returns a floating point number when ndigits is positive, self for zero, and floor down for negative.
1.2.floor #=> 1 2.0.floor #=> 2 (-1.2).floor #=> -2 (-2.0).floor #=> -2 1.234567.floor(2) #=> 1.23 1.234567.floor(3) #=> 1.234 1.234567.floor(4) #=> 1.2345 1.234567.floor(5) #=> 1.23456 34567.89.floor(-5) #=> 0 34567.89.floor(-4) #=> 30000 34567.89.floor(-3) #=> 34000 34567.89.floor(-2) #=> 34500 34567.89.floor(-1) #=> 34560 34567.89.floor(0) #=> 34567 34567.89.floor(1) #=> 34567.8 34567.89.floor(2) #=> 34567.89 34567.89.floor(3) #=> 34567.89
Returns the numerator. The result is machine dependent.
n = 0.3.numerator #=> 5404319552844595 d = 0.3.denominator #=> 18014398509481984 n.fdiv(d) #=> 0.3
Transfer control to another fiber, resuming it from where it last stopped or starting it if it was not resumed before. The calling fiber will be suspended much like in a call to Fiber.yield. You need to require 'fiber' before using this method.
The fiber which receives the transfer call is treats it much like a resume call. Arguments passed to transfer are treated like those passed to resume.
You cannot resume a fiber that transferred control to another one. This will cause a double resume error. You need to transfer control back to this fiber before it can yield and resume.
Example:
fiber1 = Fiber.new do puts "In Fiber 1" Fiber.yield end fiber2 = Fiber.new do puts "In Fiber 2" fiber1.transfer puts "Never see this message" end fiber3 = Fiber.new do puts "In Fiber 3" end fiber2.resume fiber3.resume
produces
In fiber 2 In fiber 1 In fiber 3
Closes the directory stream. Calling this method on closed Dir object is ignored since Ruby 2.3.
d = Dir.new("testdir") d.close #=> nil
Returns the path to the current working directory of this process as a string.
Dir.chdir("/tmp") #=> 0 Dir.getwd #=> "/tmp" Dir.pwd #=> "/tmp"
Expands pattern, which is an Array of patterns or a pattern String, and returns the results as matches or as arguments given to the block.
Note that this pattern is not a regexp, it’s closer to a shell glob. See File::fnmatch for the meaning of the flags parameter. Note that case sensitivity depends on your system (so File::FNM_CASEFOLD is ignored), as does the order in which the results are returned.
*
Matches any file. Can be restricted by other values in the glob. Equivalent to / .* /x in regexp.
*
Matches all files
c*
Matches all files beginning with c
*c
Matches all files ending with c
*c*
Match all files that have c in them (including at the beginning or end).
Note, this will not match Unix-like hidden files (dotfiles). In order to include those in the match results, you must use the File::FNM_DOTMATCH flag or something like "{*,.*}".
**
Matches directories recursively.
?
Matches any one character. Equivalent to /.{1}/ in regexp.
[set]
Matches any one character in set. Behaves exactly like character sets in Regexp, including set negation ([^a-z]).
{p,q}
Matches either literal p or literal q. Equivalent to pattern alternation in regexp.
Matching literals may be more than one character in length. More than two literals may be specified.
\
Escapes the next metacharacter.
Note that this means you cannot use backslash on windows as part of a glob, i.e. Dir["c:\foo*"] will not work, use Dir["c:/foo*"] instead.
Examples:
Dir["config.?"] #=> ["config.h"] Dir.glob("config.?") #=> ["config.h"] Dir.glob("*.[a-z][a-z]") #=> ["main.rb"] Dir.glob("*.[^r]*") #=> ["config.h"] Dir.glob("*.{rb,h}") #=> ["main.rb", "config.h"] Dir.glob("*") #=> ["config.h", "main.rb"] Dir.glob("*", File::FNM_DOTMATCH) #=> [".", "..", "config.h", "main.rb"] rbfiles = File.join("**", "*.rb") Dir.glob(rbfiles) #=> ["main.rb", # "lib/song.rb", # "lib/song/karaoke.rb"] libdirs = File.join("**", "lib") Dir.glob(libdirs) #=> ["lib"] librbfiles = File.join("**", "lib", "**", "*.rb") Dir.glob(librbfiles) #=> ["lib/song.rb", # "lib/song/karaoke.rb"] librbfiles = File.join("**", "lib", "*.rb") Dir.glob(librbfiles) #=> ["lib/song.rb"]
Locks or unlocks a file according to locking_constant (a logical or of the values in the table below). Returns false if File::LOCK_NB is specified and the operation would otherwise have blocked. Not available on all platforms.
Locking constants (in class File):
LOCK_EX | Exclusive lock. Only one process may hold an
| exclusive lock for a given file at a time.
----------+------------------------------------------------
LOCK_NB | Don't block when locking. May be combined
| with other lock options using logical or.
----------+------------------------------------------------
LOCK_SH | Shared lock. Multiple processes may each hold a
| shared lock for a given file at the same time.
----------+------------------------------------------------
LOCK_UN | Unlock.
Example:
# update a counter using write lock # don't use "w" because it truncates the file before lock. File.open("counter", File::RDWR|File::CREAT, 0644) {|f| f.flock(File::LOCK_EX) value = f.read.to_i + 1 f.rewind f.write("#{value}\n") f.flush f.truncate(f.pos) } # read the counter using read lock File.open("counter", "r") {|f| f.flock(File::LOCK_SH) p f.read }
Returns true if the named file exists and has a zero size.
file_name can be an IO object.
Returns the result of invoking exception.to_s. Normally this returns the exception’s message or name.
Return the receiver associated with this NameError exception.
Return this SystemCallError’s error number.
Registers filename to be loaded (using Kernel::require) the first time that module (which may be a String or a symbol) is accessed in the namespace of mod.
module A end A.autoload(:B, "b") A::B.doit # autoloads "b"
Returns filename to be loaded if name is registered as autoload in the namespace of mod.
module A end A.autoload(:B, "b") A.autoload?(:B) #=> "b"
Internal method used to provide marshalling support. See the Marshal module.
Returns the BigDecimal version number.
Returns the remainder from dividing by the value.
x.remainder(y) means x-y*(x/y).truncate
Return the largest integer less than or equal to the value, as a BigDecimal.
BigDecimal('3.14159').floor #=> 3 BigDecimal('-9.1').floor #=> -10
If n is specified and positive, the fractional part of the result has no more than that many digits.
If n is specified and negative, at least that many digits to the left of the decimal point will be 0 in the result.
BigDecimal('3.14159').floor(3) #=> 3.141 BigDecimal('13345.234').floor(-2) #=> 13300.0
Returns the value raised to the power of n.
Note that n must be an Integer.
Also available as the operator **.
Returns True if the value is zero.
Returns self if the value is non-zero, nil otherwise.
The coerce method provides support for Ruby type coercion. It is not enabled by default.
This means that binary operations like + * / or - can often be performed on a BigDecimal and an object of another type, if the other object can be coerced into a BigDecimal value.
e.g.
a = BigDecimal.new("1.0") b = a / 2.0 #=> 0.5
Note that coercing a String to a BigDecimal is not supported by default; it requires a special compile-time option when building Ruby.
Returns the numerator.
Rational(7).numerator #=> 7 Rational(7, 1).numerator #=> 7 Rational(9, -4).numerator #=> -9 Rational(-2, -10).numerator #=> 1