Results for: "fnmatch"

A Zlib::Deflate.deflate wrapper

Retrieve the PathSupport object that RubyGems uses to lookup files.

Initialize the filesystem paths to use from env. env is a hash-like object (typically ENV) that is queried for ‘GEM_HOME’, ‘GEM_PATH’, and ‘GEM_SPEC_CACHE’ Keys for the env hash should be Strings, and values of the hash should be Strings or nil.

Set array of platforms this RubyGems supports (primarily for testing).

Array of platforms this RubyGems supports.

Computes the arc tangent given y and x. Returns a Float in the range -PI..PI. Return value is a angle in radians between the positive x-axis of cartesian plane and the point given by the coordinates (x, y) on it.

Domain: (-INFINITY, INFINITY)

Codomain: [-PI, PI]

Math.atan2(-0.0, -1.0) #=> -3.141592653589793
Math.atan2(-1.0, -1.0) #=> -2.356194490192345
Math.atan2(-1.0, 0.0)  #=> -1.5707963267948966
Math.atan2(-1.0, 1.0)  #=> -0.7853981633974483
Math.atan2(-0.0, 1.0)  #=> -0.0
Math.atan2(0.0, 1.0)   #=> 0.0
Math.atan2(1.0, 1.0)   #=> 0.7853981633974483
Math.atan2(1.0, 0.0)   #=> 1.5707963267948966
Math.atan2(1.0, -1.0)  #=> 2.356194490192345
Math.atan2(0.0, -1.0)  #=> 3.141592653589793
Math.atan2(INFINITY, INFINITY)   #=> 0.7853981633974483
Math.atan2(INFINITY, -INFINITY)  #=> 2.356194490192345
Math.atan2(-INFINITY, INFINITY)  #=> -0.7853981633974483
Math.atan2(-INFINITY, -INFINITY) #=> -2.356194490192345

Computes the arc tangent of x. Returns -PI/2..PI/2.

Domain: (-INFINITY, INFINITY)

Codomain: (-PI/2, PI/2)

Math.atan(0) #=> 0.0

Computes the inverse hyperbolic tangent of x.

Domain: (-1, 1)

Codomain: (-INFINITY, INFINITY)

Math.atanh(1) #=> Infinity

Calculates the gamma function of x.

Note that gamma(n) is the same as fact(n-1) for integer n > 0. However gamma(n) returns float and can be an approximation.

def fact(n) (1..n).inject(1) {|r,i| r*i } end
1.upto(26) {|i| p [i, Math.gamma(i), fact(i-1)] }
#=> [1, 1.0, 1]
#   [2, 1.0, 1]
#   [3, 2.0, 2]
#   [4, 6.0, 6]
#   [5, 24.0, 24]
#   [6, 120.0, 120]
#   [7, 720.0, 720]
#   [8, 5040.0, 5040]
#   [9, 40320.0, 40320]
#   [10, 362880.0, 362880]
#   [11, 3628800.0, 3628800]
#   [12, 39916800.0, 39916800]
#   [13, 479001600.0, 479001600]
#   [14, 6227020800.0, 6227020800]
#   [15, 87178291200.0, 87178291200]
#   [16, 1307674368000.0, 1307674368000]
#   [17, 20922789888000.0, 20922789888000]
#   [18, 355687428096000.0, 355687428096000]
#   [19, 6.402373705728e+15, 6402373705728000]
#   [20, 1.21645100408832e+17, 121645100408832000]
#   [21, 2.43290200817664e+18, 2432902008176640000]
#   [22, 5.109094217170944e+19, 51090942171709440000]
#   [23, 1.1240007277776077e+21, 1124000727777607680000]
#   [24, 2.5852016738885062e+22, 25852016738884976640000]
#   [25, 6.204484017332391e+23, 620448401733239439360000]
#   [26, 1.5511210043330954e+25, 15511210043330985984000000]

Calculates the logarithmic gamma of x and the sign of gamma of x.

Math.lgamma(x) is the same as

[Math.log(Math.gamma(x).abs), Math.gamma(x) < 0 ? -1 : 1]

but avoids overflow by Math.gamma(x) for large x.

Math.lgamma(0) #=> [Infinity, 1]

Some operating systems retain the status of terminated child processes until the parent collects that status (normally using some variant of wait()). If the parent never collects this status, the child stays around as a zombie process. Process::detach prevents this by setting up a separate Ruby thread whose sole job is to reap the status of the process pid when it terminates. Use detach only when you do not intend to explicitly wait for the child to terminate.

The waiting thread returns the exit status of the detached process when it terminates, so you can use Thread#join to know the result. If specified pid is not a valid child process ID, the thread returns nil immediately.

The waiting thread has pid method which returns the pid.

In this first example, we don’t reap the first child process, so it appears as a zombie in the process status display.

p1 = fork { sleep 0.1 }
p2 = fork { sleep 0.2 }
Process.waitpid(p2)
sleep 2
system("ps -ho pid,state -p #{p1}")

produces:

27389 Z

In the next example, Process::detach is used to reap the child automatically.

p1 = fork { sleep 0.1 }
p2 = fork { sleep 0.2 }
Process.detach(p1)
Process.waitpid(p2)
sleep 2
system("ps -ho pid,state -p #{p1}")

(produces no output)

Returns the maximum number of gids allowed in the supplemental group access list.

Process.maxgroups   #=> 32

Sets the maximum number of gids allowed in the supplemental group access list.

Enumerates the outdated local gems yielding the local specification and the latest remote version.

This method may take some time to return as it must check each local gem against the server’s index.

Returns a Hash containing the following keys:

:accept

Number of started SSL/TLS handshakes in server mode

:accept_good

Number of established SSL/TLS sessions in server mode

:accept_renegotiate

Number of start renegotiations in server mode

:cache_full

Number of sessions that were removed due to cache overflow

:cache_hits

Number of successfully reused connections

:cache_misses

Number of sessions proposed by clients that were not found in the cache

:cache_num

Number of sessions in the internal session cache

:cb_hits

Number of sessions retrieved from the external cache in server mode

:connect

Number of started SSL/TLS handshakes in client mode

:connect_good

Number of established SSL/TLS sessions in client mode

:connect_renegotiate

Number of start renegotiations in client mode

:timeouts

Number of sessions proposed by clients that were found in the cache but had expired due to timeouts

Returns true if key is the corresponding private key to the Subject Public Key Information, false otherwise.