La calculadora binaria realiza el conjunto completo de operaciones que los programadores necesitan con números en base 2: aritmética (suma, resta, multiplicación, división, exponenciación), lógica bit a bit (AND, OR, XOR, NOT) y operadores de desplazamiento (left shift, right shift). Cada resultado se muestra a la vez en binario, decimal y hexadecimal para que puedas verificarlo a mano o copiarlo directamente al código fuente. Las entradas se aceptan en cualquiera de las tres bases — útil cuando tienes una constante hex de una hoja de datos, un valor decimal de una especificación o un literal binario de un mapa de bits — y la aritmética de precisión arbitraria mediante BigNumber.js elimina los techos de desbordamiento de 32 o 53 bits. Usos comunes: depurar operaciones con flags, construir máscaras de red, decodificar registros de hardware, calcular valores en complemento a dos y aprender cómo computa realmente una computadora.
¿Qué es Binario?
Binario es el sistema numérico que las computadoras usan de verdad. Tiene exactamente dos símbolos, 0 y 1, porque el hardware físico — transistores, dominios magnéticos, pits ópticos — puede representar de forma fiable dos estados distintos (apagado/encendido, voltaje bajo/alto) y casi nada más con la misma velocidad y fiabilidad. Toda estructura de nivel superior en computación — texto, imágenes, audio, paquetes de red, instrucciones — es, en el nivel más bajo, simplemente bits.
Cada dígito binario se llama bit. Ocho bits forman un byte (la unidad direccionable individualmente más pequeña en casi todas las computadoras modernas); 16 bits una media palabra; 32 o 64 bits una palabra, igualando el ancho nativo del registro de la CPU. Dentro de un byte, los bits se numeran desde 0 (menos significativo, a la derecha) hasta 7 (más significativo, a la izquierda). El bit en la posición k contribuye 2^k al valor cuando está activado.
El binario es un sistema posicional igual que el decimal, pero con base 2 en lugar de 10. El número binario 1010 se expande como 1×2³ + 0×2² + 1×2¹ + 0×2⁰ = 8 + 0 + 2 + 0 = 10 en decimal. El dígito principal es el más significativo — la misma convención que en decimal. Para convertir de decimal a binario, divide repetidamente por 2 y registra los restos de abajo hacia arriba; para convertir de binario a decimal, suma las potencias de 2 en cada bit activado.
La importancia del binario no es solo histórica: cada primitiva computacional — aritmética, direcciones, formatos de archivo, protocolos de red — se define en términos de bits y alineación de bytes. Entender binario directamente es lo que permite a un programador razonar sobre desbordamiento, alineación, endianness, compresión y coste de operaciones. Incluso los lenguajes de alto nivel que ocultan los bits los exponen cuando importa el rendimiento (bitsets, bloom filters, RoaringBitmap, checksums CRC, funciones hash).
¿Cómo hacer cálculos binarios?
La aritmética binaria sigue el mismo algoritmo columna por columna que aprendiste para decimal — la única diferencia es que el alfabeto tiene dos símbolos en vez de diez, así que las reglas de acarreo/préstamo son más ajustadas.
- Suma Binaria
- Mismo algoritmo de columnas que en decimal, pero la mayor suma de un solo dígito es 1 + 1 = 10₂ (que es 2 en decimal, escrito como 0 en esta columna con un 1 acarreado a la izquierda).
- Reglas de una sola columna: 0+0=0, 0+1=1, 1+0=1, 1+1=10 (lleva 1). Con un acarreo entrante: 1+1+1=11 (escribe 1, lleva 1).
- Ejemplo: 1011 (11) + 1101 (13) = 11000 (24). Verifícalo sumando columna a columna desde la derecha con los acarreos.
- El hardware suma binarios exactamente así con sumadores completos en cascada; las CPU modernas suman un par de 64 bits en un ciclo de reloj calculando todos los acarreos en paralelo (carry-lookahead).
- Resta Binaria
- Reglas de columna para resta: 0-0=0, 1-0=1, 1-1=0, 0-1 necesita un préstamo de la columna siguiente (da 1 en esta columna y resta 1 a la columna de la izquierda).
- Dentro de las CPU, la resta casi nunca se hace con un circuito separado de préstamos. En su lugar, a-b se calcula como a + (~b + 1) — suma con el complemento a dos de b — usando el mismo sumador.
- Ejemplo: 1011 (11) - 100 (4) = 111 (7). O vía complemento a dos: ~100 + 1 en 4 bits = 1100, luego 1011 + 1100 = 10111, descartas el bit de salida, queda 0111 = 7.
- Por eso los enteros en C, Java y la mayoría de lenguajes pueden envolver pasado INT_MIN/INT_MAX en silencio: a + 1 envuelve a INT_MIN cuando a == INT_MAX porque el bit de salida se descarta.
- Multiplicación Binaria
- Cada bit del multiplicador se multiplica por el multiplicando entero y los productos parciales se suman, desplazados según la posición del bit.
- Reglas de un solo bit: 0×cualquier cosa=0, 1×cualquier cosa=esa cosa (solo cópiala).
- Ejemplo: 101 (5) × 11 (3) = productos parciales 101 (×1) y 1010 (×2, desplazado un lugar a la izquierda) sumados = 1111 (15).
- El hardware lo hace con un circuito multiplicador; multiplicar dos valores de 64 bits suele ser unos pocos ciclos de reloj en x86 moderno (IMUL), pero era caro en las primeras CPU — mucho más lento que sumar. Por eso muchas bases de código antiguas usan trucos de shift-and-add.
- Cuando un operando es potencia de 2, la multiplicación degenera en un desplazamiento a la izquierda (n × 8 == n << 3). Los compiladores hacen esto automáticamente como reducción de fuerza; lo mismo para divisiones por potencias de 2 que se convierten en desplazamientos a la derecha.
- División Binaria
- La división larga binaria procede bit a bit: desplaza el divisor para alinearlo con los bits altos del dividendo, resta si entra (escribiendo un 1 en el cociente), desplaza a la derecha, repite. El resto es lo que queda tras la última resta.
- Notas Prácticas
- Escribir los valores posicionales sobre las columnas (..., 16, 8, 4, 2, 1) es la forma más rápida de convertir binario a decimal a mano. Cada '1' aporta su valor posicional; súmalos.
- Usa hex como notación intermedia: cada 4 dígitos binarios es un dígito hex, así 1010 1011 = 0xAB, sin aritmética. Por eso los volcados de memoria y los códigos de color usan hex.
- Cuidado con el tamaño de palabra al calcular en un lenguaje real: los operadores bit a bit de JavaScript truncan silenciosamente los operandos a enteros con signo de 32 bits, así que cualquier cálculo con bits 31+ se comporta de forma sorprendente. Esta calculadora usa BigNumber.js para evitarlo.
Más allá de la práctica manual y esta calculadora, todo lenguaje de programación de propósito general soporta literales binarios (0b1010 en JS, Python, Rust, C++14+) y un conjunto completo de operadores bit a bit. Para trabajo embebido, consulta la hoja de datos de tu chip — los layouts de bits de los registros casi siempre se definen en binario.
Tabla de Conversión Binario/Decimal
| Binario | Decimal |
|---|
| 0000 | 0 |
| 0001 | 1 |
| 0010 | 2 |
| 0011 | 3 |
| 0100 | 4 |
| 0101 | 5 |
| 0110 | 6 |
| 0111 | 7 |
| 1000 | 8 |
| 1001 | 9 |
| 1010 | 10 |
| 1011 | 11 |
| 1100 | 12 |
| 1101 | 13 |
| 1110 | 14 |
| 1111 | 15 |
Preguntas Frecuentes
Porque el binario solo tiene dos símbolos, 0 y 1 — el símbolo "2" simplemente no existe en este sistema. Cuando alcanzas un conteo de dos en cualquier sistema posicional, debes saltar al siguiente valor posicional. En decimal, 9 + 1 = 10 por exactamente la misma razón: 9 es el último símbolo de un solo dígito, y sumar 1 fuerza un acarreo a la columna de las decenas. En binario, 1 + 1 produce 0 en la columna de unidades y acarrea 1 a la columna de los doses, escrito como 10. El valor es dos — lo único que cambió fue la notación. Por eso los programadores bromean: "hay 10 tipos de personas en el mundo: los que entienden binario y los que no". Todo sistema posicional funciona así, incluyendo el hexadecimal: F + 1 = 10 (dieciséis), y el ternario: 2 + 1 = 10 (tres).
El complemento a dos es la representación universal de enteros con signo en el hardware moderno, y funciona reinterpretando el bit más significativo (MSB) con un peso negativo. En 8 bits, el MSB tiene peso −128 en vez de +128. Así, 11111111 en complemento a dos es −128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = −1, y 10000000 es exactamente −128. Para negar un número: invierte todos los bits (complemento a uno) y suma 1. Ejemplo: +5 = 00000101 → invierte a 11111010 → suma 1 = 11111011 = −5. El complemento a dos tiene tres propiedades deseables que impulsaron su adopción universal: (1) hay solo un cero (00000000), no dos como en signo-magnitud; (2) la suma funciona igual para con signo y sin signo — el mismo circuito sumador maneja ambos; (3) el bit de salida del bit alto se descarta, dando aritmética modular natural y desbordamiento predecible. Compromiso: el rango negativo es uno mayor que el positivo (8 bits: −128 a +127), y abs(INT_MIN) desborda.
Usa el selector de Ancho de bits (8 / 16 / 32 / 64 bits) para que coincida con el registro, campo o palabra con el que realmente trabajas — un puerto de microcontrolador de 8 bits, un campo de protocolo de 16 bits o una palabra de CPU de 32/64 bits. Cada operación bit a bit (AND, OR, XOR, NOT) y ambos desplazamientos se calculan con BigInt nativo y luego se enmascaran exactamente a ese ancho, así NOT queda por fin bien definido (NOT de 10101010 en 8 bits es 01010101, no el engañoso 4294967125 de 32 bits) y AND/OR/XOR siguen exactos incluso por encima de 2^31 o 2^53. El selector de Signo controla cómo se interpreta el resultado decimal: en modo Sin signo el patrón se lee como magnitud simple (11111111 en 8 bits = 255); en modo Con signo (complemento a dos) el bit más significativo se vuelve bit de signo (11111111 en 8 bits = -1, 10000000 = -128). El modo con signo también cambia el desplazamiento a la derecha de lógico (relleno con cero) a aritmético (extensión de signo) para que los valores negativos se desplacen correctamente. Las cajas de resultado binario y hex siempre muestran el patrón de bits crudo con ceros a la izquierda al ancho elegido, y aparece una nota si un valor no cabe y se trunca. La aritmética (suma, resta, multiplicación, división, potencia) ignora el selector de ancho y mantiene precisión arbitraria.
Los operadores bit a bit no son curiosidades académicas — aparecen constantemente en código sensible al rendimiento, código de sistema y protocolos. AND (&) prueba bits y aplica máscaras: status & 0x04 verifica si el tercer bit está activado, patrón común para leer flags de estado o extraer campos de una estructura empaquetada. OR (|) activa bits: flags = flags | LOG_INFO enciende un flag sin tocar otros. XOR (^) alterna bits o detecta diferencias: x ^ x siempre es 0, se usa en checksums; XOR-swap intercambia dos variables sin temporal; cifrado XOR con una clave. NOT (~) invierte todos los bits y se usa principalmente junto con AND para limpiar bits: flags = flags & ~LOG_DEBUG apaga LOG_DEBUG sin tocar otros. Estas cuatro operaciones son también los bloques de construcción de abstracciones de alto nivel: bitmaps, bloom filters, RoaringBitmap, máscaras de red IP (ip & netmask da la dirección de red), mezcla de colores en gráficos y funciones hash. Casi toda CPU las implementa como instrucciones de un solo ciclo; en bucles ajustados superan a cualquier alternativa condicional.
El desplazamiento a la izquierda (<<) de cualquier tipo es inequívoco: rellena con ceros a la derecha y descarta bits por la izquierda. El derecho tiene dos sabores y debes saber cuál. El lógico (>>> en JavaScript y Java, lsr en ARM) siempre rellena con 0 a la izquierda, tratando el número como sin signo — 0xFF >>> 1 = 0x7F. El aritmético (>> en JavaScript, Java, C con tipos con signo; asr en ARM) replica el bit de signo, preservando el signo de un número en complemento a dos — −2 >> 1 = −1, no 0x7FFFFFFE. Esto importa: para campos sin signo usa el lógico; para enteros con signo, el aritmético. La rotación (sin operador nativo en C o JS, intrínsecos _rotl/_rotr en x86) envuelve los bits de extremo a extremo en vez de descartarlos — útil en criptografía (AES, ChaCha usan rotaciones) y en funciones hash de ancho fijo donde necesitas una distribución equilibrada. El << normal de JavaScript trunca silenciosamente a 32 bits, así que desplazamientos más allá del bit 31 sorprenden; esta calculadora usa BigNumber.js para mantener resultados exactos a cualquier anchura.
Porque 4 dígitos binarios mapean exactamente a 1 dígito hex, sin sobras. 0000 a 1111 corresponde a 0 a F. Un valor de 32 bits son 32 dígitos binarios pero solo 8 dígitos hex, lo que entra en una línea de código y se lee de un vistazo. Hex preserva toda la estructura de bits: cada carácter hex te dice exactamente 4 bits, así 0xDEADBEEF dice inmediatamente el patrón de bits a un programador, mientras que 11011110101011011011111011101111 te marea la vista. Octal (base 8) es más antiguo y agrupa los bits de 3 en 3 — fue común en máquinas de 12 y 36 bits de los años 60 — pero el octal no divide 32 limpio, generando huecos torpes; ganó el hex. Los códigos de color RGB (#FF8800), direcciones MAC, UUIDs, direcciones de memoria, checksums de archivo y puntos de código Unicode (U+1F600) están todos en hex por esto. Al depurar código a nivel de bits, aprender a traducir dígitos hex a y desde sus patrones binarios de 4 bits a primera vista es una de las habilidades de mayor apalancamiento.
Porque el número decimal 0,1 no tiene representación binaria exacta. En base 2, 0,1 es la fracción periódica no terminante 0,000110011001100... — análogo a cómo 1/3 es 0,333... en decimal. IEEE 754 doble precisión lo redondea a 52 bits de mantisa, dando una aproximación ligeramente mayor que 0,1. Lo mismo aplica a 0,2. Cuando sumas las dos aproximaciones redondeadas y conviertes de vuelta a decimal, el error residual se vuelve visible: 0,30000000000000004. Las potencias de 2 — 0,5, 0,25, 0,125 — y sus múltiplos enteros — 0,75, 0,625 — son exactamente representables. Cualquier otra cosa tiene error de redondeo. Para cálculos financieros o cuando se requiere aritmética decimal exacta, usa una librería decimal (BigDecimal en Java, Decimal en Python, BigNumber.js en JavaScript) o escala a céntimos enteros. Para aritmética entera binaria — el foco de esta calculadora — no hay error de redondeo: enteros hasta 2^53 caben exactos en un double, y BigNumber.js nos lleva más allá.
Depende del lenguaje y del tipo de entero. C/C++ int depende de la implementación pero típicamente es 32 bits con signo: −2.147.483.648 a +2.147.483.647 (unos ±2,1 mil millones). long long es 64 bits con signo: unos ±9,2 trillones. El Number de JavaScript es un doble IEEE 754 de 64 bits, así que representa enteros exactos hasta 2^53 − 1 = 9.007.199.254.740.991 (Number.MAX_SAFE_INTEGER); más allá, los enteros consecutivos dejan de distinguirse. Los operadores bit a bit de JavaScript (&, |, ^, <<, >>, ~) hacen otra trampa: siempre truncan ambos operandos a enteros con signo de 32 bits, luego convierten de vuelta. Así 0x100000000 | 0 == 0, lo que sorprende. ES2020 añadió BigInt (literal 123n) para precisión arbitraria. Python tiene int de precisión arbitraria nativa — nunca desborda — pero paga un coste en runtime. Rust te obliga a elegir: u32, i64, u128, etc., y el desbordamiento se chequea en debug pero envuelve en release. Esta calculadora usa BigNumber.js para precisión arbitraria, así que la aritmética binaria con cientos de dígitos funciona como se espera.
El uso de patrones binarios en matemáticas es mucho anterior a Leibniz — la multiplicación egipcia antigua usaba descomposición binaria, y el erudito indio Pingala describió alrededor del 200 a.C. lo que equivale a un sistema posicional binario para analizar la métrica sánscrita. Pero Gottfried Wilhelm Leibniz, en su artículo de 1703 Explication de l'Arithmétique Binaire, dio el primer tratamiento sistemático en occidente del binario como sistema numérico completo, con reglas de suma, resta, multiplicación y división — y observó explícitamente que todos los números podían representarse usando solo 0 y 1. Leibniz se inspiró en parte en descripciones de los hexagramas del I Ching, cuyas 64 figuras corresponden exactamente a números binarios de 6 bits. El siguiente salto tardó 250 años: el álgebra de la lógica de George Boole en 1854 mostró que las proposiciones podían manipularse con dos valores de verdad, y la tesis de máster de Claude Shannon en el MIT en 1937, A Symbolic Analysis of Relay and Switching Circuits, demostró que el álgebra booleana implementada en relés eléctricos podía realizar computación arbitraria — la base de todas las computadoras digitales. El Z3 de Konrad Zuse (1941) y el ENIAC (1945) siguieron poco después. Cada CPU hoy es, al final, una enorme máquina de circuitos booleanos siguiendo el plano de Shannon.
Calculadora
Matemáticas
¿Tienes comentarios? Reporta errores, sugiere funciones o comparte tus ideas — leemos todos
CALCULADORAS MATEMáTICAS32
HERRAMIENTAS PARA DESARROLLADORES99
WUTOOLS