Checks if the object is shareable by ractors.
Ractor.shareable?(1) #=> true -- numbers and other immutable basic values are frozen Ractor.shareable?('foo') #=> false, unless the string is frozen due to # freeze_string_literals: true Ractor.shareable?('foo'.freeze) #=> true
See also the “Shareable and unshareable objects” section in the Ractor class docs.
Returns true if thr is running or sleeping.
thr = Thread.new { } thr.join #=> #<Thread:0x401b3fb0 dead> Thread.current.alive? #=> true thr.alive? #=> false
Equivalent to Kernel::gets, except readline raises EOFError at end of file.
Returns an array containing the lines returned by calling Kernel.gets(sep) until the end of file.
Use Kernel#gem to activate a specific version of gem_name.
requirements is a list of version requirements that the specified gem must match, most commonly “= example.version.number”. See Gem::Requirement for how to specify a version requirement.
If you will be activating the latest version of a gem, there is no need to call Kernel#gem, Kernel#require will do the right thing for you.
Kernel#gem returns true if the gem was activated, otherwise false. If the gem could not be found, didn’t match the version requirements, or a different version was already activated, an exception will be raised.
Kernel#gem should be called before any require statements (otherwise RubyGems may load a conflicting library version).
Kernel#gem only loads prerelease versions when prerelease requirements are given:
gem 'rake', '>= 1.1.a', '< 2'
In older RubyGems versions, the environment variable GEM_SKIP could be used to skip activation of specified gems, for example to test out changes that haven’t been installed yet. Now RubyGems defers to -I and the RUBYLIB environment variable to skip activation of a gem.
Example:
GEM_SKIP=libA:libB ruby -I../libA -I../libB ./mycode.rb
Returns an array of objects based elements of self that match the given pattern.
With no block given, returns an array containing each element for which pattern === element is true:
a = ['foo', 'bar', 'car', 'moo'] a.grep(/ar/) # => ["bar", "car"] (1..10).grep(3..8) # => [3, 4, 5, 6, 7, 8] ['a', 'b', 0, 1].grep(Integer) # => [0, 1]
With a block given, calls the block with each matching element and returns an array containing each object returned by the block:
a = ['foo', 'bar', 'car', 'moo'] a.grep(/ar/) {|element| element.upcase } # => ["BAR", "CAR"]
Related: grep_v.
Returns an array of objects based on elements of self that don’t match the given pattern.
With no block given, returns an array containing each element for which pattern === element is false:
a = ['foo', 'bar', 'car', 'moo'] a.grep_v(/ar/) # => ["foo", "moo"] (1..10).grep_v(3..8) # => [1, 2, 9, 10] ['a', 'b', 0, 1].grep_v(Integer) # => ["a", "b"]
With a block given, calls the block with each non-matching element and returns an array containing each object returned by the block:
a = ['foo', 'bar', 'car', 'moo'] a.grep_v(/ar/) {|element| element.upcase } # => ["FOO", "MOO"]
Related: grep.
Returns an array of objects rejected by the block.
With a block given, calls the block with successive elements; returns an array of those elements for which the block returns nil or false:
(0..9).reject {|i| i * 2 if i.even? } # => [1, 3, 5, 7, 9] {foo: 0, bar: 1, baz: 2}.reject {|key, value| key if value.odd? } # => {:foo=>0, :baz=>2}
When no block given, returns an Enumerator.
Related: select.
Returns an object formed from operands via either:
A method named by symbol.
A block to which each operand is passed.
With method-name argument symbol, combines operands using the method:
# Sum, without initial_operand. (1..4).inject(:+) # => 10 # Sum, with initial_operand. (1..4).inject(10, :+) # => 20
With a block, passes each operand to the block:
# Sum of squares, without initial_operand. (1..4).inject {|sum, n| sum + n*n } # => 30 # Sum of squares, with initial_operand. (1..4).inject(2) {|sum, n| sum + n*n } # => 32
Operands
If argument initial_operand is not given, the operands for inject are simply the elements of self. Example calls and their operands:
(1..4).inject(:+)
[1, 2, 3, 4].
(1...4).inject(:+)
[1, 2, 3].
('a'..'d').inject(:+)
['a', 'b', 'c', 'd'].
('a'...'d').inject(:+)
['a', 'b', 'c'].
Examples with first operand (which is self.first) of various types:
# Integer. (1..4).inject(:+) # => 10 # Float. [1.0, 2, 3, 4].inject(:+) # => 10.0 # Character. ('a'..'d').inject(:+) # => "abcd" # Complex. [Complex(1, 2), 3, 4].inject(:+) # => (8+2i)
If argument initial_operand is given, the operands for inject are that value plus the elements of self. Example calls their operands:
(1..4).inject(10, :+)
[10, 1, 2, 3, 4].
(1...4).inject(10, :+)
[10, 1, 2, 3].
('a'..'d').inject('e', :+)
['e', 'a', 'b', 'c', 'd'].
('a'...'d').inject('e', :+)
['e', 'a', 'b', 'c'].
Examples with initial_operand of various types:
# Integer. (1..4).inject(2, :+) # => 12 # Float. (1..4).inject(2.0, :+) # => 12.0 # String. ('a'..'d').inject('foo', :+) # => "fooabcd" # Array. %w[a b c].inject(['x'], :push) # => ["x", "a", "b", "c"] # Complex. (1..4).inject(Complex(2, 2), :+) # => (12+2i)
Combination by Given Method
If the method-name argument symbol is given, the operands are combined by that method:
The first and second operands are combined.
That result is combined with the third operand.
That result is combined with the fourth operand.
And so on.
The return value from inject is the result of the last combination.
This call to inject computes the sum of the operands:
(1..4).inject(:+) # => 10
Examples with various methods:
# Integer addition. (1..4).inject(:+) # => 10 # Integer multiplication. (1..4).inject(:*) # => 24 # Character range concatenation. ('a'..'d').inject('', :+) # => "abcd" # String array concatenation. %w[foo bar baz].inject('', :+) # => "foobarbaz" # Hash update. h = [{foo: 0, bar: 1}, {baz: 2}, {bat: 3}].inject(:update) h # => {:foo=>0, :bar=>1, :baz=>2, :bat=>3} # Hash conversion to nested arrays. h = {foo: 0, bar: 1}.inject([], :push) h # => [[:foo, 0], [:bar, 1]]
Combination by Given Block
If a block is given, the operands are passed to the block:
The first call passes the first and second operands.
The second call passes the result of the first call, along with the third operand.
The third call passes the result of the second call, along with the fourth operand.
And so on.
The return value from inject is the return value from the last block call.
This call to inject gives a block that writes the memo and element, and also sums the elements:
(1..4).inject do |memo, element| p "Memo: #{memo}; element: #{element}" memo + element end # => 10
Output:
"Memo: 1; element: 2" "Memo: 3; element: 3" "Memo: 6; element: 4"
Enumerable#reduce is an alias for Enumerable#inject.
Returns whether for any element object == element:
(1..4).include?(2) # => true (1..4).include?(5) # => false (1..4).include?('2') # => false %w[a b c d].include?('b') # => true %w[a b c d].include?('2') # => false {foo: 0, bar: 1, baz: 2}.include?(:foo) # => true {foo: 0, bar: 1, baz: 2}.include?('foo') # => false {foo: 0, bar: 1, baz: 2}.include?(0) # => false
Enumerable#member? is an alias for Enumerable#include?.
Solves a*x = b for x, using LU decomposition.
a is a matrix, b is a constant vector, x is the solution vector.
ps is the pivot, a vector which indicates the permutation of rows performed during LU decomposition.
See also Newton
Start/resume the coverage measurement.
Caveat: Currently, only process-global coverage measurement is supported. You cannot measure per-thread covearge. If your process has multiple thread, using Coverage.resume/suspend to capture code coverage executed from only a limited code block, may yield misleading results.
Returns a hash that contains filename as key and coverage array as value. If clear is true, it clears the counters to zero. If stop is true, it disables coverage measurement.
Resets the process of reading the /etc/group file, so that the next call to ::getgrent will return the first entry again.
Ends the process of scanning through the /etc/group file begun by ::getgrent, and closes the file.
Returns an entry from the /etc/group file.
The first time it is called it opens the file and returns the first entry; each successive call returns the next entry, or nil if the end of the file has been reached.
To close the file when processing is complete, call ::endgrent.
Each entry is returned as a Group struct
Change the size of the memory allocated at the memory location addr to size bytes. Returns the memory address of the reallocated memory, which may be different than the address passed in.
Free the memory at address addr