module Math

Extended Modules

Defined in:

big/big_float.cr
big/big_int.cr
big/big_rational.cr
complex.cr
math/math.cr

Constant Summary

E = LibM.exp_f64(1.0)

Euler's number (e).

LOG10 = LibM.log_f64(10.0)
LOG2 = LibM.log_f64(2.0)
PI = 3.14159265358979323846

Archimedes' constant (π).

TAU = 6.283185307179586476925

The full circle constant (τ), equal to 2π.

Instance Method Summary

Instance Method Detail

def acos(value : Float32) : Float32 #

Calculates the arc cosine of value.


[View source]
def acos(value : Float64) : Float64 #

Calculates the arc cosine of value.


[View source]
def acos(value) #

Calculates the arc cosine of value.


[View source]
def acosh(value : Float32) : Float32 #

Calculates the inverse hyperbolic cosine of value.


[View source]
def acosh(value : Float64) : Float64 #

Calculates the inverse hyperbolic cosine of value.


[View source]
def acosh(value) #

Calculates the inverse hyperbolic cosine of value.


[View source]
def asin(value : Float32) : Float32 #

Calculates the arc sine of value.


[View source]
def asin(value : Float64) : Float64 #

Calculates the arc sine of value.


[View source]
def asin(value) #

Calculates the arc sine of value.


[View source]
def asinh(value : Float32) : Float32 #

Calculates the inverse hyperbolic sine of value.


[View source]
def asinh(value : Float64) : Float64 #

Calculates the inverse hyperbolic sine of value.


[View source]
def asinh(value) #

Calculates the inverse hyperbolic sine of value.


[View source]
def atan(value : Float32) : Float32 #

Calculates the arc tangent of value.


[View source]
def atan(value : Float64) : Float64 #

Calculates the arc tangent of value.


[View source]
def atan(value) #

Calculates the arc tangent of value.


[View source]
def atan2(y : Float32, x : Float32) : Float32 #

Calculates the two-argument arc tangent of the ray from (0, 0) to (x, y).


[View source]
def atan2(y : Float64, x : Float64) : Float64 #

Calculates the two-argument arc tangent of the ray from (0, 0) to (x, y).


[View source]
def atan2(y, x) : Float64 #

Calculates the two-argument arc tangent of the ray from (0, 0) to (x, y).


[View source]
def atanh(value : Float32) : Float32 #

Calculates the inverse hyperbolic tangent of value.


[View source]
def atanh(value : Float64) : Float64 #

Calculates the inverse hyperbolic tangent of value.


[View source]
def atanh(value) #

Calculates the inverse hyperbolic tangent of value.


[View source]
def besselj(order : Int32, value : Float32) #

Calculates the cylindrical Bessel function of the first kind of value for the given order.


[View source]
def besselj(order : Int32, value : Float64) : Float64 #

Calculates the cylindrical Bessel function of the first kind of value for the given order.


[View source]
def besselj(order, value) #

Calculates the cylindrical Bessel function of the first kind of value for the given order.


[View source]
def besselj0(value : Float32) #

Calculates the cylindrical Bessel function of the first kind of value for order 0.


[View source]
def besselj0(value : Float64) : Float64 #

Calculates the cylindrical Bessel function of the first kind of value for order 0.


[View source]
def besselj0(value) #

Calculates the cylindrical Bessel function of the first kind of value for order 0.


[View source]
def besselj1(value : Float32) #

Calculates the cylindrical Bessel function of the first kind of value for order 1.


[View source]
def besselj1(value : Float64) : Float64 #

Calculates the cylindrical Bessel function of the first kind of value for order 1.


[View source]
def besselj1(value) #

Calculates the cylindrical Bessel function of the first kind of value for order 1.


[View source]
def bessely(order : Int32, value : Float32) #

Calculates the cylindrical Bessel function of the second kind of value for the given order.


[View source]
def bessely(order : Int32, value : Float64) : Float64 #

Calculates the cylindrical Bessel function of the second kind of value for the given order.


[View source]
def bessely(order, value) #

Calculates the cylindrical Bessel function of the second kind of value for the given order.


[View source]
def bessely0(value : Float32) #

Calculates the cylindrical Bessel function of the second kind of value for order 0.


[View source]
def bessely0(value : Float64) : Float64 #

Calculates the cylindrical Bessel function of the second kind of value for order 0.


[View source]
def bessely0(value) #

Calculates the cylindrical Bessel function of the second kind of value for order 0.


[View source]
def bessely1(value : Float32) #

Calculates the cylindrical Bessel function of the second kind of value for order 1.


[View source]
def bessely1(value : Float64) : Float64 #

Calculates the cylindrical Bessel function of the second kind of value for order 1.


[View source]
def bessely1(value) #

Calculates the cylindrical Bessel function of the second kind of value for order 1.


[View source]
def cbrt(value : Float32) : Float32 #

Calculates the cubic root of value.


[View source]
def cbrt(value : Float64) : Float64 #

Calculates the cubic root of value.


[View source]
def cbrt(value) #

Calculates the cubic root of value.


[View source]
def copysign(value1 : Float32, value2 : Float32) #

Returns the floating-point value with the magnitude of value1 and the sign of value2.


[View source]
def copysign(value1 : Float64, value2 : Float64) : Float64 #

Returns the floating-point value with the magnitude of value1 and the sign of value2.


[View source]
def copysign(value1, value2) #

Returns the floating-point value with the magnitude of value1 and the sign of value2.


[View source]
def cos(value : Float32) : Float32 #

Calculates the cosine of value, measured in radians.


[View source]
def cos(value : Float64) : Float64 #

Calculates the cosine of value, measured in radians.


[View source]
def cos(value) #

Calculates the cosine of value, measured in radians.


[View source]
def cosh(value : Float32) : Float32 #

Calculates the hyperbolic cosine of value.


[View source]
def cosh(value : Float64) : Float64 #

Calculates the hyperbolic cosine of value.


[View source]
def cosh(value) #

Calculates the hyperbolic cosine of value.


[View source]
def erf(value : Float32) : Float32 #

Calculates the error function of value.


[View source]
def erf(value : Float64) : Float64 #

Calculates the error function of value.


[View source]
def erf(value) #

Calculates the error function of value.


[View source]
def erfc(value : Float32) : Float32 #

Calculates 1 minus the error function of value.


[View source]
def erfc(value : Float64) : Float64 #

Calculates 1 minus the error function of value.


[View source]
def erfc(value) #

Calculates 1 minus the error function of value.


[View source]
def exp(value : Float32) : Float32 #

Calculates the exponential of value.


[View source]
def exp(value : Float64) : Float64 #

Calculates the exponential of value.


[View source]
def exp(value : Complex) : Complex #

Calculates the exponential of value.

require "complex"

Math.exp(4 + 2.i) # => -22.720847417619233 + 49.645957334580565.i

[View source]
def exp(value) #

Calculates the exponential of value.


[View source]
def exp2(value : Float32) : Float32 #

Calculates 2 raised to the power value.


[View source]
def exp2(value : Float64) : Float64 #

Calculates 2 raised to the power value.


[View source]
def exp2(value) #

Calculates 2 raised to the power value.


[View source]
def expm1(value : Float32) : Float32 #

Calculates the exponential of value, minus 1.


[View source]
def expm1(value : Float64) : Float64 #

Calculates the exponential of value, minus 1.


[View source]
def expm1(value) #

Calculates the exponential of value, minus 1.


[View source]
def frexp(value : Float32) : Tuple(Float32, Int32) #

Decomposes the given floating-point value into a normalized fraction and an integral power of two.


[View source]
def frexp(value : Float64) : Tuple(Float64, Int32) #

Decomposes the given floating-point value into a normalized fraction and an integral power of two.


[View source]
def frexp(value : BigFloat) : Tuple(BigFloat, Int64) #

Decomposes the given floating-point value into a normalized fraction and an integral power of two.


[View source]
def frexp(value) #

Decomposes the given floating-point value into a normalized fraction and an integral power of two.


[View source]
def gamma(value : Float32) : Float32 #

Calculates the gamma function of value.

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


[View source]
def gamma(value : Float64) : Float64 #

Calculates the gamma function of value.

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


[View source]
def gamma(value) : Float64 #

Calculates the gamma function of value.

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


[View source]
def hypot(value1 : Float32, value2 : Float32) : Float32 #

Calculates the length of the hypotenuse from (0, 0) to (value1, value2).

Equivalent to

Math.sqrt(value1 ** 2 + value2 ** 2)

[View source]
def hypot(value1 : Float64, value2 : Float64) : Float64 #

Calculates the length of the hypotenuse from (0, 0) to (value1, value2).

Equivalent to

Math.sqrt(value1 ** 2 + value2 ** 2)

[View source]
def hypot(value1, value2) #

Calculates the length of the hypotenuse from (0, 0) to (value1, value2).

Equivalent to

Math.sqrt(value1 ** 2 + value2 ** 2)

[View source]
def ilogb(value : Float32) : Int32 #

Returns the unbiased base 2 exponent of the given floating-point value.


[View source]
def ilogb(value : Float64) : Int32 #

Returns the unbiased base 2 exponent of the given floating-point value.


[View source]
def ilogb(value) #

Returns the unbiased base 2 exponent of the given floating-point value.


[View source]
def isqrt(value : Int::Primitive) #

Calculates the integer square root of value.


[View source]
def isqrt(value : BigInt) #

Calculates the integer square root of value.


[View source]
def ldexp(value : Float32, exp : Int32) : Float32 #

Multiplies the given floating-point value by 2 raised to the power exp.


[View source]
def ldexp(value : Float64, exp : Int32) : Float64 #

Multiplies the given floating-point value by 2 raised to the power exp.


[View source]
def ldexp(value, exp) #

Multiplies the given floating-point value by 2 raised to the power exp.


[View source]
def lgamma(value : Float32) #

Calculates the logarithmic gamma of value.

Math.lgamma(2.96)

is equivalent to

Math.log(Math.gamma(2.96).abs)

[View source]
def lgamma(value : Float64) : Float64 #

Calculates the logarithmic gamma of value.

Math.lgamma(2.96)

is equivalent to

Math.log(Math.gamma(2.96).abs)

[View source]
def lgamma(value) : Float64 #

Calculates the logarithmic gamma of value.

Math.lgamma(2.96)

is equivalent to

Math.log(Math.gamma(2.96).abs)

[View source]
def log(value, base) #

Calculates the logarithm of value to the given base.


[View source]
def log(value : Float32) : Float32 #

Calculates the natural logarithm of value.


[View source]
def log(value : Float64) : Float64 #

Calculates the natural logarithm of value.


[View source]
def log(value : Complex) : Complex #

Calculates the natural logarithm of value.

require "complex"

Math.log(4 + 2.i) # => 1.4978661367769956 + 0.4636476090008061.i

[View source]
def log(value) : Float64 #

Calculates the natural logarithm of value.


[View source]
def log10(value : Float32) : Float32 #

Calculates the logarithm of value to base 10.


[View source]
def log10(value : Float64) : Float64 #

Calculates the logarithm of value to base 10.


[View source]
def log10(value : Complex) : Complex #

Calculates the logarithm of value to base 10.

require "complex"

Math.log10(4 + 2.i) # => 0.6505149978319906 + 0.20135959813668655.i

[View source]
def log10(value) #

Calculates the logarithm of value to base 10.


[View source]
def log1p(value : Float32) : Float32 #

Calculates the natural logarithm of 1 plus value.


[View source]
def log1p(value : Float64) : Float64 #

Calculates the natural logarithm of 1 plus value.


[View source]
def log1p(value) #

Calculates the natural logarithm of 1 plus value.


[View source]
def log2(value : Float32) : Float32 #

Calculates the logarithm of value to base 2.


[View source]
def log2(value : Float64) : Float64 #

Calculates the logarithm of value to base 2.


[View source]
def log2(value : Complex) : Complex #

Calculates the logarithm of value to base 2.

require "complex"

Math.log2(4 + 2.i) # => 2.1609640474436813 + 0.6689021062254881.i

[View source]
def log2(value) : Float64 #

Calculates the logarithm of value to base 2.


[View source]
def logb(value : Float32) : Float32 #

Returns the unbiased radix-independent exponent of the given floating-point value.

For Float32 and Float64 this is equivalent to #ilogb.


[View source]
def logb(value : Float64) : Float64 #

Returns the unbiased radix-independent exponent of the given floating-point value.

For Float32 and Float64 this is equivalent to #ilogb.


[View source]
def logb(value) #

Returns the unbiased radix-independent exponent of the given floating-point value.

For Float32 and Float64 this is equivalent to #ilogb.


[View source]
def max(value1 : Float32, value2 : Float32) #

Returns the greater of value1 and value2.


[View source]
def max(value1 : Float64, value2 : Float64) : Float64 #

Returns the greater of value1 and value2.


[View source]
def max(value1, value2) #

Returns the greater of value1 and value2.


[View source]
def min(value1 : Float32, value2 : Float32) #

Returns the smaller of value1 and value2.


[View source]
def min(value1 : Float64, value2 : Float64) : Float64 #

Returns the smaller of value1 and value2.


[View source]
def min(value1, value2) #

Returns the smaller of value1 and value2.


[View source]
def pw2ceil(v : Int::Primitive) #

Computes the smallest nonnegative power of 2 that is greater than or equal to v.

The returned value has the same type as the argument. Raises OverflowError if the result does not fit into the argument's type.

Math.pw2ceil(33) # => 64
Math.pw2ceil(64) # => 64
Math.pw2ceil(-5) # => 1

[View source]
def pw2ceil(v : BigInt) : BigInt #

Computes the smallest nonnegative power of 2 that is greater than or equal to v.

The returned value has the same type as the argument.

Math.pw2ceil(33) # => 64
Math.pw2ceil(64) # => 64
Math.pw2ceil(-5) # => 1

[View source]
def scalbln(value : Float32, exp : Int64) #

Returns the floating-point value with its exponent raised by exp.

For Float32 and Float64 this is equivalent to #ldexp.


[View source]
def scalbln(value : Float64, exp : Int64) : Float64 #

Returns the floating-point value with its exponent raised by exp.

For Float32 and Float64 this is equivalent to #ldexp.


[View source]
def scalbln(value, exp) : Float64 #

Returns the floating-point value with its exponent raised by exp.

For Float32 and Float64 this is equivalent to #ldexp.


[View source]
def scalbn(value : Float32, exp : Int32) : Float32 #

Returns the floating-point value with its exponent raised by exp.

For Float32 and Float64 this is equivalent to #ldexp.


[View source]
def scalbn(value : Float64, exp : Int32) : Float64 #

Returns the floating-point value with its exponent raised by exp.

For Float32 and Float64 this is equivalent to #ldexp.


[View source]
def scalbn(value, exp) #

Returns the floating-point value with its exponent raised by exp.

For Float32 and Float64 this is equivalent to #ldexp.


[View source]
def sin(value : Float32) : Float32 #

Calculates the sine of value, measured in radians.


[View source]
def sin(value : Float64) : Float64 #

Calculates the sine of value, measured in radians.


[View source]
def sin(value) #

Calculates the sine of value, measured in radians.


[View source]
def sinh(value : Float32) : Float32 #

Calculates the hyperbolic sine of value.


[View source]
def sinh(value : Float64) : Float64 #

Calculates the hyperbolic sine of value.


[View source]
def sinh(value) #

Calculates the hyperbolic sine of value.


[View source]
def sqrt(value : Float32) : Float32 #

Calculates the square root of value.


[View source]
def sqrt(value : Float64) : Float64 #

Calculates the square root of value.


[View source]
def sqrt(value : BigInt) : BigFloat #

Calculates the square root of value.

require "big"

Math.sqrt(1_000_000_000_000.to_big_i * 1_000_000_000_000.to_big_i) # => 1000000000000.0

[View source]
def sqrt(value : BigFloat) : BigFloat #

Calculates the square root of value.

require "big"

Math.sqrt(1_000_000_000_000.to_big_f * 1_000_000_000_000.to_big_f) # => 1000000000000.0

[View source]
def sqrt(value : BigRational) : BigFloat #

Calculates the square root of value.

require "big"

Math.sqrt(1_000_000_000_000.to_big_r * 1_000_000_000_000.to_big_r) # => 1000000000000.0

[View source]
def sqrt(value : Complex) : Complex #

Calculates the square root of value. Inspired by the following blog post of Pavel Panchekha on floating point precision.

require "complex"

Math.sqrt(4 + 2.i) # => 2.0581710272714924 + 0.48586827175664565.i

Although the imaginary number is defined as i = sqrt(-1), calling Math.sqrt with a negative number will return -NaN. To obtain the result in the complex plane, Math.sqrt must be called with a complex number.

Math.sqrt(-1.0)         # => -NaN
Math.sqrt(-1.0 + 0.0.i) # => 0.0 + 1.0.i

[View source]
def sqrt(value) : Float64 #

Calculates the square root of value.


[View source]
def tan(value : Float32) : Float32 #

Calculates the tangent of value, measured in radians.


[View source]
def tan(value : Float64) : Float64 #

Calculates the tangent of value, measured in radians.


[View source]
def tan(value) #

Calculates the tangent of value, measured in radians.


[View source]
def tanh(value : Float32) : Float32 #

Calculates the hyperbolic tangent of value.


[View source]
def tanh(value : Float64) : Float64 #

Calculates the hyperbolic tangent of value.


[View source]
def tanh(value) #

Calculates the hyperbolic tangent of value.


[View source]