Computes the arc sine of x. Returns -PI/2..PI/2.
Domain: [-1, -1]
Codomain: [-PI/2, PI/2]
Math.asin(1) == Math::PI/2 #=> true
Computes the hyperbolic sine of x (expressed in radians).
Domain: (-INFINITY, INFINITY)
Codomain: (-INFINITY, INFINITY)
Math.sinh(0) #=> 0.0
Computes the inverse hyperbolic sine of x.
Domain: (-INFINITY, INFINITY)
Codomain: (-INFINITY, INFINITY)
Math.asinh(1) #=> 0.881373587019543
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]
Gets the resource limit of the process. cur_limit means current (soft) limit and max_limit means maximum (hard) limit.
resource indicates the kind of resource to limit. It is specified as a symbol such as :CORE, a string such as "CORE" or a constant such as Process::RLIMIT_CORE. See Process.setrlimit for details.
cur_limit and max_limit may be Process::RLIM_INFINITY, Process::RLIM_SAVED_MAX or Process::RLIM_SAVED_CUR. See Process.setrlimit and the system getrlimit(2) manual for details.
Sets the resource limit of the process. cur_limit means current (soft) limit and max_limit means maximum (hard) limit.
If max_limit is not given, cur_limit is used.
resource indicates the kind of resource to limit. It should be a symbol such as :CORE, a string such as "CORE" or a constant such as Process::RLIMIT_CORE. The available resources are OS dependent. Ruby may support following resources.
total available memory (bytes) (SUSv3, NetBSD, FreeBSD, OpenBSD but 4.4BSD-Lite)
core size (bytes) (SUSv3)
CPU time (seconds) (SUSv3)
data segment (bytes) (SUSv3)
file size (bytes) (SUSv3)
total size for mlock(2) (bytes) (4.4BSD, GNU/Linux)
allocation for POSIX message queues (bytes) (GNU/Linux)
ceiling on process’s nice(2) value (number) (GNU/Linux)
file descriptors (number) (SUSv3)
number of processes for the user (number) (4.4BSD, GNU/Linux)
resident memory size (bytes) (4.2BSD, GNU/Linux)
ceiling on the process’s real-time priority (number) (GNU/Linux)
CPU time for real-time process (us) (GNU/Linux)
all socket buffers (bytes) (NetBSD, FreeBSD)
number of queued signals allowed (signals) (GNU/Linux)
stack size (bytes) (SUSv3)
cur_limit and max_limit may be :INFINITY, "INFINITY" or Process::RLIM_INFINITY, which means that the resource is not limited. They may be Process::RLIM_SAVED_MAX, Process::RLIM_SAVED_CUR and corresponding symbols and strings too. See system setrlimit(2) manual for details.
The following example raises the soft limit of core size to the hard limit to try to make core dump possible.
Process.setrlimit(:CORE, Process.getrlimit(:CORE)[1])
Initializes the supplemental group access list by reading the system group database and using all groups of which the given user is a member. The group with the specified gid is also added to the list. Returns the resulting Array of the gids of all the groups in the supplementary group access list. Not available on all platforms.
Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27] Process.initgroups( "mgranger", 30 ) #=> [30, 6, 10, 11] Process.groups #=> [30, 6, 10, 11]
Return the best specification that contains the file matching path amongst the specs that are not activated.
Search through all unresolved deps and sub-dependencies and return specs that contain the file matching path.
Like Enumerable#map, but chains operation to be lazy-evaluated.
(1..Float::INFINITY).lazy.map {|i| i**2 } #=> #<Enumerator::Lazy: #<Enumerator::Lazy: 1..Infinity>:map> (1..Float::INFINITY).lazy.map {|i| i**2 }.first(3) #=> [1, 4, 9]