number

abs

|Number| -> Number

Returns the absolute value of the number.

Example

-1.abs()
#: 1

1.abs()
#: 1

acos

|Number| -> Number

Returns the arc cosine of the number. acos is the inverse function of cos.

Example

from number import pi

assert_near 0.acos(), pi / 2
assert_eq 1.acos(), 0

acosh

|Number| -> Number

Returns the inverse hyperbolic cosine of the number.

Example

assert 0.acosh().is_nan()
assert_eq 1.acosh(), 0
assert_near 2.acosh(), 1.3169578969248166

and

|Number, Number| -> Number

Returns the bitwise combination of the binary representations of two numbers, where a 1 in both of the inputs produces a 1 in the corresponding output position.

Note

If either input is a float then its integer part will be used.

Example

0b1010.and 0b1100
# 0b1000
#: 8

asin

|Number| -> Number

Returns the arc sine of the number. asin is the inverse function of sin.

Example

from number import pi

assert_eq 0.asin(), 0
assert_near 1.asin(), pi / 2

asinh

|Number| -> Number

Returns the inverse hyperbolic sine of the number.

Example

assert_eq 0.asinh(), 0
assert_near 1.asinh(), 0.8813735870195429

atan

|Number| -> Number

Returns the arc tangent of the number. atan is the inverse function of tan.

Example

from number import pi

assert_eq 0.atan(), 0
assert_near 1.atan(), pi / 4

atanh

|Number| -> Number

Returns the inverse hyperbolic tangent of the number.

Example

-1.atanh()
#: -inf

0.atanh()
#: 0.0

1.atanh()
#: inf

atan2

|Number, Number| -> Number

Returns the arc tangent of y and x in radians, using the signs of y and x to determine the correct quadrant.

Example

from number import pi

x, y = 1, 1

assert_near y.atan2(x), pi / 4
assert_near y.atan2(-x), pi - pi / 4

ceil

|Number| -> Number

Returns the integer that's greater than or equal to the input.

Example

0.5.ceil()
#: 1

2.ceil()
#: 2

-0.5.ceil()
#: 0

See Also

• number.floor
• number.round
• number.to_int

clamp

|input: Number, min: Number, max: Number| -> Number

Returns the input number restricted to the range defined by min and max.

Example

0.clamp 1, 2
#: 1

1.5.clamp 1, 2
#: 1.5

3.0.clamp 1, 2
#: 2

cos

|Number| -> Number

Returns the cosine of the number.

Example

0.cos()
#: 1.0

number.pi.cos()
#: -1.0

cosh

|Number| -> Number

Returns the hyperbolic cosine of the number.

Example

assert_eq 0.cosh(), 1
assert_near 1.cosh(), 1.5430806348152437

degrees

|Number| -> Number

Converts radians into degrees.

Example

from number import pi, tau

pi.degrees()
#: 180.0

tau.degrees()
#: 360.0

e

Number

Provides the e constant.

exp

|Number| -> Number

Returns the result of applying the exponential function, equivalent to calling e ^ x.

Example

assert_eq 0.exp(), 1
assert_eq 1.exp(), number.e

exp2

|Number| -> Number

Returns the result of applying the base-2 exponential function, equivalent to calling 2 ^ x.

Example

1.exp2()
#: 2.0

3.exp2()
#: 8.0

flip_bits

|Number| -> Number

Returns the input with its bits 'flipped', i.e. 1 => 0, and 0 => 1.

Example

1.flip_bits()
#: -2

floor

|Number| -> Number

Returns the integer that's less than or equal to the input.

Example

0.5.floor()
#: 0

2.floor()
#: 2

-0.5.floor()
#: -1

See Also

• number.ceil
• number.round
• number.to_int

infinity

Number

Provides the ∞ constant.

is_int

|Number| -> Bool

Returns true if the number is an integer.

Example

1.is_int()
#: true

1.5.is_int()
#: false

See Also

• number.is_nan
• number.to_int

is_nan

|Number| -> Bool

Returns true if the number is NaN.

Example

1.is_nan()
#: false

(0 / 0).is_nan()
#: true

See Also

• number.is_int

lerp

|a: Number, b: Number, t: Number| -> Number

Linearly interpolates between a and b using the interpolation factor t.

The range (a -> b) corresponds to the value range of (0 -> 1) for t.

e.g.

• At t == 0, the result is equal to a.
• At t == 1, the result is equal to b.
• At other values of t, the result is a proportional mix of a and b.
• Values for t outside of (0 -> 1) will extrapolate from the (a -> b) range.

Example

a, b = 1, 2

a.lerp b, 0
#: 1
a.lerp b, 0.5
#: 1.5
a.lerp b, 1
#: 2

a.lerp b, -0.5
#: 0.5
a.lerp b, 1.5
#: 2.5

ln

|Number| -> Number

Returns the natural logarithm of the number.

Example

1.ln()
#: 0.0

number.e.ln()
#: 1.0

log2

|Number| -> Number

Returns the base-2 logarithm of the number.

Example

2.log2()
#: 1.0

4.log2()
#: 2.0

log10

|Number| -> Number

Returns the base-10 logarithm of the number.

Example

10.log10()
#: 1.0

100.log10()
#: 2.0

max

|Number, Number| -> Number

Returns the larger of the two numbers.

Example

1.max 2
#: 2

4.5.max 3
#: 4.5

min

|Number, Number| -> Number

Returns the smaller of the two numbers.

Example

1.min 2
#: 1

4.5.min 3
#: 3

nan

Number

Provides the NaN (Not a Number) constant.

negative_infinity

Number

Provides the -∞ constant.

or

|Number, Number| -> Number

Returns the bitwise combination of the binary representations of two numbers, where a 1 in either of the inputs produces a 1 in the corresponding output position.

Note

If either input is a float then its integer part will be used.

Example

0b1010.or 0b1100
# 0b1110
#: 14

pi

Number

Provides the π constant.

pi_2

Number

Provides the π constant divided by 2.

pi_4

Number

Provides the π constant divided by 4.

radians

|Number| -> Number

Converts degrees into radians.

Example

from number import pi

assert_near 90.radians(), pi / 2
assert_near 360.radians(), pi * 2

recip

|Number| -> Number

Returns the reciprocal of the number, i.e. 1 / x.

Example

2.recip()
#: 0.5

round

|Number| -> Number

Returns the nearest integer to the input number. Half-way values round away from zero.

Example

0.5.round()
#: 1

2.round()
#: 2

-0.5.round()
#: -1

See Also

• number.ceil
• number.floor
• number.to_int

shift_left

|Number, shift_amount: Number| -> Number

Returns the result of shifting the bits of the first number to the left by the amount specified by the second number.

Note

If either input is a float then its integer part will be used.

Note

The shift amount must be greater than or equal to 0.

Example

0b1010.shift_left 2
# 0b101000
#: 40

shift_right

|Number, shift_amount: Number| -> Number

Returns the result of shifting the bits of the first number to the right by the amount specified by the second number.

Note

If either input is a float then its integer part will be used.

Note

The shift amount must be greater than or equal to 0.

Example

0b1010.shift_right 2
# 0b0010
#: 2

sin

|Number| -> Number

Returns the sine of the number.

Example

from number import pi

(pi * 0.5).sin()
#: 1.0

(pi * 1.5).sin()
#: -1.0

sinh

|Number| -> Number

Returns the hyperbolic sine of the number.

Example

assert_eq 0.sinh(), 0
assert_near 1.sinh(), 1.1752011936438014

sqrt

|Number| -> Number

Returns the square root of the number.

Example

64.sqrt()
#: 8.0

tan

|Number| -> Number

Returns the tangent of the number.

Example

assert_eq 0.tan(), 0
assert_near 1.tan(), 1.557407724654902

tanh

|Number| -> Number

Returns the hyperbolic tangent of the number.

Example

assert_near 1.tanh(), 1.sinh() / 1.cosh()

tau

Number

Provides the τ constant, equivalent to 2π.

to_int

|Number| -> Number

Returns the integer part of the input number.

This is often called trunc in other languages.

Example

2.9.to_int()
#: 2

1.5.to_int()
#: 1

-0.5.to_int()
#: 0

-1.9.to_int()
#: -1

See Also

• number.ceil
• number.floor
• number.is_int
• number.round

xor

|Number, Number| -> Number

Returns the bitwise combination of the binary representations of two numbers, where a 1 in one (and only one) of the input positions produces a 1 in the corresponding output position.

Note

If either input is a float then its integer part will be used.

Example

0b1010.xor 0b1100
# 0b0110
#: 6