Replaces the contents of the set with the contents of the given enumerable object and returns self.
Equivalent to Set#delete_if, but returns nil if no changes were made.
Creates a temporary file as usual File object (not Tempfile). It doesn’t use finalizer and delegation.
If no block is given, this is similar to Tempfile.new except creating File instead of Tempfile. The created file is not removed automatically. You should use File.unlink to remove it.
If a block is given, then a File object will be constructed, and the block is invoked with the object as the argument. The File object will be automatically closed and the temporary file is removed after the block terminates. The call returns the value of the block.
In any case, all arguments (+*args+) will be treated as Tempfile.new.
Tempfile.create('foo', '/home/temp') do |f|
... do something with f ...
end
Returns true if there are no threads in the pool still running.
Returns true if there are no threads in the pool still running.
Wraps the block in a single, VM-global Mutex.synchronize, returning the value of the block. A thread executing inside the exclusive section will only block other threads which also use the Thread.exclusive mechanism.
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 every element in enum for which Pattern === element. If the optional block is supplied, each matching element is passed to it, and the block’s result is stored in the output array.
(1..100).grep 38..44 #=> [38, 39, 40, 41, 42, 43, 44] c = IO.constants c.grep(/SEEK/) #=> [:SEEK_SET, :SEEK_CUR, :SEEK_END] res = c.grep(/SEEK/) { |v| IO.const_get(v) } res #=> [0, 1, 2]
Inverted version of Enumerable#grep. Returns an array of every element in enum for which not Pattern === element.
(1..10).grep_v 2..5 #=> [1, 6, 7, 8, 9, 10] res =(1..10).grep_v(2..5) { |v| v * 2 } res #=> [2, 12, 14, 16, 18, 20]
Returns an array for all elements of enum for which the given block returns false.
If no block is given, an Enumerator is returned instead.
(1..10).reject { |i| i % 3 == 0 } #=> [1, 2, 4, 5, 7, 8, 10] [1, 2, 3, 4, 5].reject { |num| num.even? } #=> [1, 3, 5]
See also Enumerable#find_all.
Combines all elements of enum by applying a binary operation, specified by a block or a symbol that names a method or operator.
If you specify a block, then for each element in enum the block is passed an accumulator value (memo) and the element. If you specify a symbol instead, then each element in the collection will be passed to the named method of memo. In either case, the result becomes the new value for memo. At the end of the iteration, the final value of memo is the return value for the method.
If you do not explicitly specify an initial value for memo, then the first element of collection is used as the initial value of memo.
# Sum some numbers (5..10).reduce(:+) #=> 45 # Same using a block and inject (5..10).inject { |sum, n| sum + n } #=> 45 # Multiply some numbers (5..10).reduce(1, :*) #=> 151200 # Same using a block (5..10).inject(1) { |product, n| product * n } #=> 151200 # find the longest word longest = %w{ cat sheep bear }.inject do |memo, word| memo.length > word.length ? memo : word end longest #=> "sheep"
Returns true if any member of enum equals obj. Equality is tested using ==.
IO.constants.include? :SEEK_SET #=> true IO.constants.include? :SEEK_NO_FURTHER #=> false IO.constants.member? :SEEK_SET #=> true IO.constants.member? :SEEK_NO_FURTHER #=> false
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
Returns a hash that contains filename as key and coverage array as value and 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