# Numbers

The number data type, or double, represents a double-precision (64-bit) floating-point number. Numbers can range from -1.7 * 10308 to 1.7 * 10308 (around 15 digits of precision, positive or negative).

## Signed and Unsigned

The sign of the number indicates whether it's positive or negative. For example, 1 is positive and -1 is negative. In Luau, the number -0 is equivalent to 0.

``````print(0 == -0)  --> true
print(-0 > 1)  --> false
print(-0 < 1)  --> true
print(-0 > -1)  --> true
print(-0 < -1)  --> false``````

## Number Classifications

Luau doesn't distinguish between integers and numbers, but the API reference sometimes distinguishes between them to be more specific about how to use each API.

### float

The float number type refers to a real number with a decimal place. In computer science terms, they are single-precision (32-bit) floating-point number, which isn't as precise as double-precision floating-point numbers, but is sufficiently precise for most use cases and requires less memory and storage.

### int

The integer number type, or int, refers to a 32-bit whole number, which ranges from -231 to 231 - 1. Properties and functions that expect integers may automatically round or raise errors when you assign or pass non-integers to them.

### int64

The int64 number type refers to a signed 64-bit integer, which ranges from -263 to 263 - 1. This type of integer is common for methods that use ID numbers from the Roblox website. For example, Player.UserId is an int64, and MarketplaceService:PromptPurchase() and TeleportService:Teleport() each expect int64 for the ID arguments.

## Notation

Numbers are notated with the most significant digits first (big-endian). There are multiple ways to notate number literals in Roblox Lua:

• Decimal (base-10) — Write the digits of the number normally using digits 0–9 with a single optional decimal point, for example 7, 1.25, or -22.5.
• Scientific notation — Write a decimal number followed by e or e+, then an integer to raise the decimal number to a power of 10. For instance, 12e3 is 12 × 10^3 (12,000).
• Hexadecimal (base-16) — Begin the number with 0x followed by digits 0–9 or A–F (capitalization ignored). For example, 0xF is 15 and 0x3FC is 1020.
• Binary (base-2) — Begin the number with 0b followed by 0s or 1s, for instance 0b1100 (12 in decimal format).

## Operations

You can use logical and relational operators to manipulate and compare numbers. You can also use mathematical functions such as math.sqrt() and math.exp() in the math library and bitwise operations in the bit32 library.

## Type Introspection

You can determine if a value x is a number by using type(x) or typeof(x). Both return the string number if x is a number.

``````local testInt = 5
local testDecimal = 9.12761656
local testString = "Hello"

print(type(testInt))  --> number
print(type(testDecimal))  --> number
print(type(testString))  --> string

print(typeof(testInt))  --> number
print(typeof(testDecimal))  --> number
print(typeof(testString))  --> string``````

## Rounding Functions

You can round numbers using math.floor(), math.ceil(), or math.modf(). These functions return an integer result if Luau can represent it as an integer. If the number is too large, Luau returns it as a float.

• To determine if a number x is an integer, use math.floor(x) == x.
• To round a number down, use math.floor().
• To round a number up, use math.ceil().
• To round a number towards zero, use math.modf(). It also returns the fractional difference of the rounded number as a second result.
``````print(math.floor(3.3))  --> 3
print(math.floor(-3.3))  --> -4
print(math.ceil(3.3))  --> 4
print(math.ceil(-3.3))  --> -3
print(math.modf(3.3))  --> 3 0.2999999999999998
print(math.modf(-3.3))  --> -3 -0.2999999999999998``````