A Zlib::Inflate#inflate wrapper
Formats params according to format_string which is described in setup_params.
@return [RequirementState] the current state the resolution is
operating upon
Returns an array containing the elements in self corresponding to the given selector(s).
The selectors may be either integer indices or ranges.
See also Array#select.
a = %w{ a b c d e f } a.values_at(1, 3, 5) # => ["b", "d", "f"] a.values_at(1, 3, 5, 7) # => ["b", "d", "f", nil] a.values_at(-1, -2, -2, -7) # => ["f", "e", "e", nil] a.values_at(4..6, 3...6) # => ["e", "f", nil, "d", "e", "f"]
Deletes the element at the specified index, returning that element, or nil if the index is out of range.
See also Array#slice!
a = ["ant", "bat", "cat", "dog"] a.delete_at(2) #=> "cat" a #=> ["ant", "bat", "dog"] a.delete_at(99) #=> nil
Passes elements to the block until the block returns nil or false, then stops iterating and returns an array of all prior elements.
If no block is given, an Enumerator is returned instead.
See also Array#drop_while
a = [1, 2, 3, 4, 5, 0] a.take_while { |i| i < 3 } #=> [1, 2]
Returns true if str starts with one of the prefixes given.
"hello".start_with?("hell") #=> true # returns true if one of the prefixes matches. "hello".start_with?("heaven", "hell") #=> true "hello".start_with?("heaven", "paradise") #=> false
Returns the next representable floating-point number.
Float::MAX.next_float and Float::INFINITY.next_float is Float::INFINITY.
Float::NAN.next_float is Float::NAN.
For example:
p 0.01.next_float #=> 0.010000000000000002 p 1.0.next_float #=> 1.0000000000000002 p 100.0.next_float #=> 100.00000000000001 p 0.01.next_float - 0.01 #=> 1.734723475976807e-18 p 1.0.next_float - 1.0 #=> 2.220446049250313e-16 p 100.0.next_float - 100.0 #=> 1.4210854715202004e-14 f = 0.01; 20.times { printf "%-20a %s\n", f, f.to_s; f = f.next_float } #=> 0x1.47ae147ae147bp-7 0.01 # 0x1.47ae147ae147cp-7 0.010000000000000002 # 0x1.47ae147ae147dp-7 0.010000000000000004 # 0x1.47ae147ae147ep-7 0.010000000000000005 # 0x1.47ae147ae147fp-7 0.010000000000000007 # 0x1.47ae147ae148p-7 0.010000000000000009 # 0x1.47ae147ae1481p-7 0.01000000000000001 # 0x1.47ae147ae1482p-7 0.010000000000000012 # 0x1.47ae147ae1483p-7 0.010000000000000014 # 0x1.47ae147ae1484p-7 0.010000000000000016 # 0x1.47ae147ae1485p-7 0.010000000000000018 # 0x1.47ae147ae1486p-7 0.01000000000000002 # 0x1.47ae147ae1487p-7 0.010000000000000021 # 0x1.47ae147ae1488p-7 0.010000000000000023 # 0x1.47ae147ae1489p-7 0.010000000000000024 # 0x1.47ae147ae148ap-7 0.010000000000000026 # 0x1.47ae147ae148bp-7 0.010000000000000028 # 0x1.47ae147ae148cp-7 0.01000000000000003 # 0x1.47ae147ae148dp-7 0.010000000000000031 # 0x1.47ae147ae148ep-7 0.010000000000000033 f = 0.0 100.times { f += 0.1 } p f #=> 9.99999999999998 # should be 10.0 in the ideal world. p 10-f #=> 1.9539925233402755e-14 # the floating-point error. p(10.0.next_float-10) #=> 1.7763568394002505e-15 # 1 ulp (units in the last place). p((10-f)/(10.0.next_float-10)) #=> 11.0 # the error is 11 ulp. p((10-f)/(10*Float::EPSILON)) #=> 8.8 # approximation of the above. p "%a" % f #=> "0x1.3fffffffffff5p+3" # the last hex digit is 5. 16 - 5 = 11 ulp.
Returns the previous representable floating-point number.
(-Float::MAX).prev_float and (-Float::INFINITY).prev_float is -Float::INFINITY.
Float::NAN.prev_float is Float::NAN.
For example:
p 0.01.prev_float #=> 0.009999999999999998 p 1.0.prev_float #=> 0.9999999999999999 p 100.0.prev_float #=> 99.99999999999999 p 0.01 - 0.01.prev_float #=> 1.734723475976807e-18 p 1.0 - 1.0.prev_float #=> 1.1102230246251565e-16 p 100.0 - 100.0.prev_float #=> 1.4210854715202004e-14 f = 0.01; 20.times { printf "%-20a %s\n", f, f.to_s; f = f.prev_float } #=> 0x1.47ae147ae147bp-7 0.01 # 0x1.47ae147ae147ap-7 0.009999999999999998 # 0x1.47ae147ae1479p-7 0.009999999999999997 # 0x1.47ae147ae1478p-7 0.009999999999999995 # 0x1.47ae147ae1477p-7 0.009999999999999993 # 0x1.47ae147ae1476p-7 0.009999999999999992 # 0x1.47ae147ae1475p-7 0.00999999999999999 # 0x1.47ae147ae1474p-7 0.009999999999999988 # 0x1.47ae147ae1473p-7 0.009999999999999986 # 0x1.47ae147ae1472p-7 0.009999999999999985 # 0x1.47ae147ae1471p-7 0.009999999999999983 # 0x1.47ae147ae147p-7 0.009999999999999981 # 0x1.47ae147ae146fp-7 0.00999999999999998 # 0x1.47ae147ae146ep-7 0.009999999999999978 # 0x1.47ae147ae146dp-7 0.009999999999999976 # 0x1.47ae147ae146cp-7 0.009999999999999974 # 0x1.47ae147ae146bp-7 0.009999999999999972 # 0x1.47ae147ae146ap-7 0.00999999999999997 # 0x1.47ae147ae1469p-7 0.009999999999999969 # 0x1.47ae147ae1468p-7 0.009999999999999967
Returns the path parameter passed to dir’s constructor.
d = Dir.new("..") d.path #=> ".."
Converts a pathname to an absolute pathname. Relative paths are referenced from the current working directory of the process unless dir_string is given, in which case it will be used as the starting point. The given pathname may start with a “~”, which expands to the process owner’s home directory (the environment variable HOME must be set correctly). “~user” expands to the named user’s home directory.
File.expand_path("~oracle/bin") #=> "/home/oracle/bin"
A simple example of using dir_string is as follows.
File.expand_path("ruby", "/usr/bin") #=> "/usr/bin/ruby"
A more complex example which also resolves parent directory is as follows. Suppose we are in bin/mygem and want the absolute path of lib/mygem.rb.
File.expand_path("../../lib/mygem.rb", __FILE__) #=> ".../path/to/project/lib/mygem.rb"
So first it resolves the parent of __FILE__, that is bin/, then go to the parent, the root of the project and appends lib/mygem.rb.
Converts a pathname to an absolute pathname. Relative paths are referenced from the current working directory of the process unless dir_string is given, in which case it will be used as the starting point. If the given pathname starts with a “~” it is NOT expanded, it is treated as a normal directory name.
File.absolute_path("~oracle/bin") #=> "<relative_path>/~oracle/bin"
Returns the pathname used to create file as a string. Does not normalize the name.
File.new("testfile").path #=> "testfile" File.new("/tmp/../tmp/xxx", "w").path #=> "/tmp/../tmp/xxx"
Returns true if the named file is readable by the real user and group id of this process. See access(3).
If file_name is readable by others, returns an integer representing the file permission bits of file_name. Returns nil otherwise. The meaning of the bits is platform dependent; on Unix systems, see stat(2).
file_name can be an IO object.
File.world_readable?("/etc/passwd") #=> 420 m = File.world_readable?("/etc/passwd") sprintf("%o", m) #=> "644"
Returns true if the named file is writable by the real user and group id of this process. See access(3)
If file_name is writable by others, returns an integer representing the file permission bits of file_name. Returns nil otherwise. The meaning of the bits is platform dependent; on Unix systems, see stat(2).
file_name can be an IO object.
File.world_writable?("/tmp") #=> 511 m = File.world_writable?("/tmp") sprintf("%o", m) #=> "777"
Returns true if the named file is executable by the real user and group id of this process. See access(3).
Returns whether ASCII-compatible or not.
Encoding::UTF_8.ascii_compatible? #=> true Encoding::UTF_16BE.ascii_compatible? #=> false