Números y bases enteras

Literales decimales, agrupados, científicos y compactos, operadores rápidos y bases enteras exactas (hexadecimal, binaria, octal).

Numlex acepta los números como los escribe la gente — miles agrupados, notación científica, sufijos compactos como 1.5M — y también las formas enteras exactas 0x, 0b y 0o que llevan una línea a las formas enteras exactas.

Esta página documenta las propias formas literales, las ambigüedades de los sufijos compactos que conviene conocer (5m son cinco millones, no cinco metros), los operadores rápidos opcionales, las bases enteras con sus reglas de presentación y desbordamiento, y el conjunto completo de ejemplos.

Literales decimales

El separador decimal es . o , según el formato regional — consulta Formatos de número y presentación.
Los separadores de miles en la entrada se normalizan: 1,234 → 1234, 1 234 (según el formato). Dentro de llamadas a funciones, una coma puede separar argumentos — consulta Funciones integradas.
Notación científica: 1.5e6, 2E-3.
Los espacios alrededor de los operadores son arbitrarios; los paréntesis ( ) agrupan; se permiten los signos unarios + y -.

Sufijos compactos

Los sufijos compactos van inmediatamente después del número, sin espacio, y se aplican a escalares y sumas de dinero:

Sufijo	Factor	Ejemplos
`k` / `K`	×10³	`1.5k` = 1.500; `$2.5k` = $2.500
`m` / `M`	×10⁶	`1.5M` = 1.500.000; `$2.5M` = $2.500.000

Dos cosas que conviene saber:

5m son 5.000.000, no cinco metros. Un metro requiere un espacio: 5 m.
G, T y P no son sufijos escalares ni de dinero. 1.5G tacha la letra G como palabra desconocida y devuelve 1.5. Giga y tera existen solo como nombres del catálogo de unidades usados con espacio: 2 Gm, 2 Gb, 2 Gbyte.

Operadores rápidos (ajuste)

Con el ajuste Quick operators activado, cuatro letras actúan como operadores solo entre dos dígitos, nunca dentro de identificadores:

Letra	Operador
`p`	`+`
`m`	`−`
`x`	`×`
`d`	`÷`

El literal 0x… nunca se convierte en multiplicación.

Bases enteras (exactas)

Los literales radix usan un prefijo estricto; el caso del prefijo no importa (0X, 0B, 0O funcionan):

Prefijo	Base	Dígitos
`0x`	16	`0-9 A-F`
`0b`	2	`0 1`
`0o`	8	`0-7`

Reglas:

Guiones bajos solo entre dos dígitos: 0x1_0, 100_000. Los dobles, los de los extremos o los que van justo tras el prefijo son errores (0x_1F, 0x1F_).
Signo-magnitud: -0x10 = −16. La magnitud del literal está limitada a 0x7FFFFFFFFFFFFFFF (9223372036854775807) en cualquier base: -0x7FFFFFFFFFFFFFFF se acepta, mientras que -0x8000000000000000 y 0x8000000000000000 superan el máximo exacto y son errores. El desbordamiento de dígitos (0x10000000000000000) también es un error.
Presentación: los resultados no negativos se muestran en la base de la expresión (0x1F + 1 → 0x20). Los negativos y las operaciones fuera de los enteros exactos (división con resto, ^ con exponente negativo) se muestran en decimal (-0x10 → −16).
Las cadenas de dígitos decimales normales no son enteros exactos. 9223372036854775808 pasa a 9.22e18. El manejo exacto se aplica solo a los literales de base, las funciones int/bin/oct/hex y las frases as / in / to base.

Nombres de base y frases

Los nombres de base no distinguen mayúsculas:

Nombre	Base
`decimal`, `base10`	10
`binary`, `base2`	2
`octal`, `base8`	8
`hex`, `hexadecimal`, `base16`	16
`base 2` / `base 8` / `base 10` / `base 16` (entero separado por espacio)	2 / 8 / 10 / 16

<expr> as <base name>          255 as hex            → 0xFF
<expr> in <base name>          99 in binary          → 0b1100011
<expr> to base 8               64 to base 8          → 0o100

Operaciones bit a bit

El modo de enteros exactos se activa con literales 0x/0b/0o, llamadas int(/bin(/oct(/hex(, frases … as|in <base> y … to base N, y los glifos bit a bit & | << >> o la palabra xor (los glifos solo cuentan cuando la línea tiene contenido matemático: fish & chips sigue siendo prosa). Las palabras and/or actúan como bit a bit solo cuando ambos lados son enteros.

Operación	Significado	Notas
`&`	AND bit a bit
`\|`	OR bit a bit	el glifo es siempre bit a bit: los operandos booleanos son un error (`false \| (1/0 > 0)`)
`xor`	XOR bit a bit (palabra)	`6 xor 3` = 5
`<<`	desplazamiento a la izquierda	desplazamiento 0…63; el desbordamiento es un error
`>>`	desplazamiento a la derecha	desplazamiento 0…63; aritmético para negativos
`/`	división entera	el resultado es un número decimal cuando hay resto
`%`	resto
`^`	potencia	el exponente se comprueba; un exponente negativo produce un número decimal

Todos los valores aquí son enteros exactos: 0x7FFFFFFFFFFFFFFF = 9223372036854775807, y el desbordamiento es un error visible, nunca un «envolvimiento» ni un número redondeado en silencio. Las palabras and/or/xor son contextuales: dos enteros las vuelven bit a bit, dos booleanos vuelven and/or lógicas, y mezclar tipos en un mismo operador es un error estricto. Usa paréntesis explícitos en las fronteras.

La precedencia completa de operadores está documentada en Operadores y lógica.

Ejemplos verificados

0x1F + 1              → 0x20
0x1F in decimal       → 31
0b101101 + 1          → 0b101110
0o55 + 1              → 0o56
0x1_0                 → 0x10
100_000 as hex        → 0x186A0
256 as hex            → 0x100
16 in binary          → 0b10000
-0x10                 → -16
1 << 4                → 16
32 >> 2               → 8
0xFF & 0x0F           → 0x0F
5 | 2                 → 7
6 xor 3               → 5
5 << 3                → 40
(5 << 3) / 2          → 20

x = 0x1F
x & 1                 → 1
x + 1                 → 0x20
x as hex              → 0x1F

Las cuatro últimas líneas se ejecutan en una sola hoja, con x declarada una vez.

Relacionado

Operadores y lógica — precedencia y las tablas completas de enteros exactos.
Funciones integradas — int, bin, oct, hex y las otras 19.
Tokens de respuesta — cómo la representación radix sobrevive a un token.