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.


def acos(value : Float64) : Float64 #

Calculates the arc cosine of value.


def acos(value) #

Calculates the arc cosine of value.


def acosh(value : Float32) : Float32 #

Calculates the inverse hyperbolic cosine of value.


def acosh(value : Float64) : Float64 #

Calculates the inverse hyperbolic cosine of value.


def acosh(value) #

Calculates the inverse hyperbolic cosine of value.


def asin(value : Float32) : Float32 #

Calculates the arc sine of value.


def asin(value : Float64) : Float64 #

Calculates the arc sine of value.


def asin(value) #

Calculates the arc sine of value.


def asinh(value : Float32) : Float32 #

Calculates the inverse hyperbolic sine of value.


def asinh(value : Float64) : Float64 #

Calculates the inverse hyperbolic sine of value.


def asinh(value) #

Calculates the inverse hyperbolic sine of value.


def atan(value : Float32) : Float32 #

Calculates the arc tangent of value.


def atan(value : Float64) : Float64 #

Calculates the arc tangent of value.


def atan(value) #

Calculates the arc tangent of value.


def atan2(y : Float32, x : Float32) : Float32 #

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


def atan2(y : Float64, x : Float64) : Float64 #

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


def atan2(y, x) : Float64 #

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


def atanh(value : Float32) : Float32 #

Calculates the inverse hyperbolic tangent of value.


def atanh(value : Float64) : Float64 #

Calculates the inverse hyperbolic tangent of value.


def atanh(value) #

Calculates the inverse hyperbolic tangent of value.


def besselj(order : Int32, value : Float32) #

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


def besselj(order : Int32, value : Float64) : Float64 #

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


def besselj(order, value) #

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


def besselj0(value : Float32) #

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


def besselj0(value : Float64) : Float64 #

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


def besselj0(value) #

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


def besselj1(value : Float32) #

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


def besselj1(value : Float64) : Float64 #

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


def besselj1(value) #

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


def bessely(order : Int32, value : Float32) #

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


def bessely(order : Int32, value : Float64) : Float64 #

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


def bessely(order, value) #

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


def bessely0(value : Float32) #

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


def bessely0(value : Float64) : Float64 #

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


def bessely0(value) #

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


def bessely1(value : Float32) #

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


def bessely1(value : Float64) : Float64 #

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


def bessely1(value) #

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


def cbrt(value : Float32) : Float32 #

Calculates the cubic root of value.


def cbrt(value : Float64) : Float64 #

Calculates the cubic root of value.


def cbrt(value) #

Calculates the cubic root of value.


def copysign(value1 : Float32, value2 : Float32) #

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


def copysign(value1 : Float64, value2 : Float64) : Float64 #

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


def copysign(value1 : BigFloat, value2 : BigFloat) : BigFloat #

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

BigFloat does not support signed zeros; if value2 == 0, the returned value is non-negative.


def copysign(value1, value2) #

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


def cos(value : Float32) : Float32 #

Calculates the cosine of value, measured in radians.


def cos(value : Float64) : Float64 #

Calculates the cosine of value, measured in radians.


def cos(value) #

Calculates the cosine of value, measured in radians.


def cosh(value : Float32) : Float32 #

Calculates the hyperbolic cosine of value.


def cosh(value : Float64) : Float64 #

Calculates the hyperbolic cosine of value.


def cosh(value) #

Calculates the hyperbolic cosine of value.


def erf(value : Float32) : Float32 #

Calculates the error function of value.


def erf(value : Float64) : Float64 #

Calculates the error function of value.


def erf(value) #

Calculates the error function of value.


def erfc(value : Float32) : Float32 #

Calculates 1 minus the error function of value.


def erfc(value : Float64) : Float64 #

Calculates 1 minus the error function of value.


def erfc(value) #

Calculates 1 minus the error function of value.


def exp(value : Float32) : Float32 #

Calculates the exponential of value.


def exp(value : Float64) : Float64 #

Calculates the exponential of value.


def exp(value : Complex) : Complex #

Calculates the exponential of value.

require "complex"

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

def exp(value) #

Calculates the exponential of value.


def exp2(value : Float32) : Float32 #

Calculates 2 raised to the power value.


def exp2(value : Float64) : Float64 #

Calculates 2 raised to the power value.


def exp2(value) #

Calculates 2 raised to the power value.


def expm1(value : Float32) : Float32 #

Calculates the exponential of value, minus 1.


def expm1(value : Float64) : Float64 #

Calculates the exponential of value, minus 1.


def expm1(value) #

Calculates the exponential of value, minus 1.


def fma(value1 : Float32, value2 : Float32, value3 : Float32) : Float32 #

Fused multiply-add; returns value1 * value2 + value3, performing a single rounding instead of two.

Math.fma(0.1, 10.0, -1.0) # => 5.551115123125783e-17
1.0 * 10.0 - 1.0          # => 0.0

def fma(value1 : Float64, value2 : Float64, value3 : Float64) : Float64 #

Fused multiply-add; returns value1 * value2 + value3, performing a single rounding instead of two.

Math.fma(0.1, 10.0, -1.0) # => 5.551115123125783e-17
1.0 * 10.0 - 1.0          # => 0.0

def fma(value1, value2, value3) #

Fused multiply-add; returns value1 * value2 + value3, performing a single rounding instead of two.

Math.fma(0.1, 10.0, -1.0) # => 5.551115123125783e-17
1.0 * 10.0 - 1.0          # => 0.0

def frexp(value : Float32) : Tuple(Float32, Int32) #

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


def frexp(value : Float64) : Tuple(Float64, Int32) #

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


def frexp(value : BigFloat) : Tuple(BigFloat, Int64) #

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


def frexp(value) #

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


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.


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.


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.


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)

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)

def hypot(value1, value2) #

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

Equivalent to

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

def ilogb(value : Float32) : Int32 #

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


def ilogb(value : Float64) : Int32 #

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


def ilogb(value : BigFloat) : Int64 #

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

Raises ArgumentError if value is zero.


def ilogb(value) #

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


def isqrt(value : Int::Primitive) #

Calculates the integer square root of value.


def isqrt(value : BigInt) #

Calculates the integer square root of value.


def ldexp(value : Float32, exp : Int32) : Float32 #

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


def ldexp(value : Float64, exp : Int32) : Float64 #

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


def ldexp(value : BigFloat, exp : Int) : BigFloat #

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


def ldexp(value, exp) #

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


def lgamma(value : Float32) #

Calculates the logarithmic gamma of value.

Math.lgamma(2.96)

is equivalent to

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

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)

def lgamma(value) : Float64 #

Calculates the logarithmic gamma of value.

Math.lgamma(2.96)

is equivalent to

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

def log(value, base) #

Calculates the logarithm of value to the given base.


def log(value : Float32) : Float32 #

Calculates the natural logarithm of value.


def log(value : Float64) : Float64 #

Calculates the natural logarithm of value.


def log(value : Complex) : Complex #

Calculates the natural logarithm of value.

require "complex"

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

def log(value) : Float64 #

Calculates the natural logarithm of value.


def log10(value : Float32) : Float32 #

Calculates the logarithm of value to base 10.


def log10(value : Float64) : Float64 #

Calculates the logarithm of value to base 10.


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

def log10(value) #

Calculates the logarithm of value to base 10.


def log1p(value : Float32) : Float32 #

Calculates the natural logarithm of 1 plus value.


def log1p(value : Float64) : Float64 #

Calculates the natural logarithm of 1 plus value.


def log1p(value) #

Calculates the natural logarithm of 1 plus value.


def log2(value : Float32) : Float32 #

Calculates the logarithm of value to base 2.


def log2(value : Float64) : Float64 #

Calculates the logarithm of value to base 2.


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

def log2(value) : Float64 #

Calculates the logarithm of value to base 2.


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.


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.


def logb(value : BigFloat) : BigFloat #

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

For BigFloat this is equivalent to #ilogb.

Raises ArgumentError is value is zero.


def logb(value) #

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

For Float32 and Float64 this is equivalent to #ilogb.


def max(value1 : Float32, value2 : Float32) #

Returns the greater of value1 and value2.


def max(value1 : Float64, value2 : Float64) : Float64 #

Returns the greater of value1 and value2.


def max(value1, value2) #

Returns the greater of value1 and value2.


def min(value1 : Float32, value2 : Float32) #

Returns the smaller of value1 and value2.


def min(value1 : Float64, value2 : Float64) : Float64 #

Returns the smaller of value1 and value2.


def min(value1, value2) #

Returns the smaller of value1 and value2.


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

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

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.


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.


def scalbln(value : BigFloat, exp : Int) : BigFloat #

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

For BigFloat this is equivalent to #ldexp.


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.


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.


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.


def scalbn(value : BigFloat, exp : Int) : BigFloat #

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

For BigFloat this is equivalent to #ldexp.


def scalbn(value, exp) #

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

For Float32 and Float64 this is equivalent to #ldexp.


def sin(value : Float32) : Float32 #

Calculates the sine of value, measured in radians.


def sin(value : Float64) : Float64 #

Calculates the sine of value, measured in radians.


def sin(value) #

Calculates the sine of value, measured in radians.


def sinh(value : Float32) : Float32 #

Calculates the hyperbolic sine of value.


def sinh(value : Float64) : Float64 #

Calculates the hyperbolic sine of value.


def sinh(value) #

Calculates the hyperbolic sine of value.


def sqrt(value : Float32) : Float32 #

Calculates the square root of value.


def sqrt(value : Float64) : Float64 #

Calculates the square root of value.


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

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

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

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

def sqrt(value) : Float64 #

Calculates the square root of value.


def tan(value : Float32) : Float32 #

Calculates the tangent of value, measured in radians.


def tan(value : Float64) : Float64 #

Calculates the tangent of value, measured in radians.


def tan(value) #

Calculates the tangent of value, measured in radians.


def tanh(value : Float32) : Float32 #

Calculates the hyperbolic tangent of value.


def tanh(value : Float64) : Float64 #

Calculates the hyperbolic tangent of value.


def tanh(value) #

Calculates the hyperbolic tangent of value.