Formato de número de computadora
Un formato de número de computadora es la representación interna de valores numéricos en hardware y software de dispositivos digitales, como en computadoras y calculadoras electrónicas.[1] Los valores numéricos se almacenan como agrupaciones de bits, como bytes y palabras. La codificación entre valores numéricos y patrones de bits se elige por conveniencia de la operación de la computadora;[1] la codificación utilizada por el conjunto de [2] de un ordenador requiere conversión para su uso externo, ya sea para visualización o su impresión. Los distintos tipos de procesadores pueden tener diferentes representaciones internas de valores numéricos y se utilizan diversas convenciones para representar números enteros y reales. La mayoría de los cálculos se realizan con formatos numéricos que encajan en un registro de procesador, pero algunos sistemas de software permiten la representación de números arbitrariamente grandes utilizando varias palabras de memoria.
Representación de números binarios editar
Las computadoras representan datos en conjuntos de dígitos binarios. La representación está compuesta por bits, que a su vez se agrupan en conjuntos más grandes, como bytes.
| Cadena binaria | Valor octal |
|---|---|
| 000 | 0 |
| 001 | 1 |
| 010 | 2 |
| 011 | 3 |
| 100 | 4 |
| 101 | 5 |
| 110 | 6 |
| 111 | 7 |
| Longitud de una cadena de bits (b) | Número de posibles valores (N) |
|---|---|
| 1 | 2 |
| 2 | 4 |
| 3 | 8 |
| 4 | 16 |
| 5 | 32 |
| 6 | 64 |
| 7 | 128 |
| 8 | 256 |
| 9 | 512 |
| 10 | 1024 |
| ... | |
Un bit es un dígito binario que representa uno de dos posibles estados. El concepto de bit puede entenderse como un valor de 1 o de 0, activado o desactivado, sí o no, verdadero o falso, o codificado mediante algún tipo de interruptor de dos posiciones.
Si bien un solo bit, por sí solo, puede representar solo dos valores, se puede usar una cadena de bits para representar valores más grandes. Por ejemplo, una cadena de tres bits puede representar hasta ocho valores distintos, como se ilustra en la Tabla 1.
A medida que aumenta el número de bits que componen una cadena, el número de posibles combinaciones "0" y "1" aumenta exponencialmente. Un solo bit permite únicamente dos combinaciones de valores, dos bits combinados pueden representar cuatro valores distintos, con tres bits se obtienen ocho, y así sucesivamente, aumentando con la fórmula 2n. La cantidad de combinaciones posibles se duplica con cada dígito binario agregado como se ilustra en la Tabla 2.
Las agrupaciones con un número específico de bits se utilizan para representar diferentes conceptos y tienen nombres específicos.
Un byte es una cadena de bits que contiene el número de bits necesarios para representar un carácter. En la mayoría de las computadoras modernas, esta es una cadena de ocho bits. Debido a que la definición de un byte está relacionada con la cantidad de bits que componen un carácter, algunas computadoras más antiguas han usado una longitud de bits diferente para su byte.[2] En muchas arquitecturas de ordenador, el byte es la unidad direccionable más pequeña, es decir, es el átomo de la direccionabilidad de un sistema informático.[3] Por ejemplo, aunque los procesadores de 64 bits pueden direccionar en la memoria sesenta y cuatro bits a la vez, aún pueden dividir esa memoria en partes de ocho bits. Esto se denomina memoria direccionable por bytes. Históricamente, muchas unidades centrales de procesamiento leen datos en múltiplos de ocho bits.[4] Debido a que el tamaño de bytes de ocho bits es tan común, aunque la definición no está estandarizada, el término octeto se usa a veces para describir explícitamente una secuencia de ocho bits.
Un nibble (a veces también escrito nybble), es un número compuesto por cuatro bits.[5] El significado en inglés de la palabra "nibble" (mordisco), es un juego de palabras que hace referencia a que se trata de un fragmento de un byte. Debido a que cuatro bits permiten representar dieciséis valores, un nibble a veces se conoce como dígito hexadecimal.[6]
Visualización de números octales y hexadecimales editar
El sistema octal y la codificación hexadecimal son formas convenientes de representar números binarios, tal como los usan las computadoras. Los ingenieros informáticos a menudo necesitan escribir cantidades binarias, pero en la práctica escribir un número binario como 1001001101010001 es tedioso y propenso a errores. Por lo tanto, las cantidades binarias se escriben en un formato de base 8, u "octal", o, mucho más comúnmente, en base 16, "hexadecimal" (hex), formato numérico. En el sistema decimal, hay 10 dígitos, del 0 al 9, que se combinan para formar números. En un sistema octal, solo hay 8 dígitos, del 0 al 7. Es decir, el valor de un "10" octal es el mismo que un "8" decimal, un "20" octal es un "16" decimal, por lo que un sistema hexadecimal, hay 16 dígitos: los comprendidos del 0 al 9, seguidos por convención, de la A a la F. Es decir, un "10" hexadecimal es lo mismo que un "16" decimal y un "20" hexadecimal es lo mismo que un "32" decimal. En el cuadro siguiente se describe un ejemplo y una comparación de números en diferentes bases.
Al escribir números, los caracteres de formato se utilizan para describir el sistema numérico, por ejemplo, 000_0000B o 0b000_00000 para números binarios y 0F8H o 0xf8 para números hexadecimales.
Conversión entre bases editar
| Decimal | Binario | Octal | Hexadecimal |
|---|---|---|---|
| 0 | 000000 | 00 | 00 |
| 1 | 000001 | 01 | 01 |
| 2 | 000010 | 02 | 02 |
| 3 | 000011 | 03 | 03 |
| 4 | 000100 | 04 | 04 |
| 5 | 000101 | 05 | 05 |
| 6 | 000110 | 06 | 06 |
| 7 | 000111 | 07 | 07 |
| 8 | 001000 | 10 | 08 |
| 9 | 001001 | 11 | 09 |
| 10 | 001010 | 12 | 0A |
| 11 | 001011 | 13 | 0B |
| 12 | 001100 | 14 | 0C |
| 13 | 001101 | 15 | 0D |
| 14 | 001110 | 16 | 0E |
| 15 | 001111 | 17 | 0F |
Cada uno de estos sistemas numéricos es un sistema posicional, pero mientras que las posiciones decimales representas potencias de 10, las posiciones octales son potencias de 8 y los posiciones hexadecimales son potencias de 16. Para convertir de hexadecimal u octal a decimal, para cada dígito 1, se multiplica el valor del dígito por el valor de su posición y luego se suman los resultados. Por ejemplo:
![{\displaystyle {\begin{aligned}&{\text{octal }}756\\[5pt]={}&(7\times 8^{2})+(5\times 8^{1})+(6\times 8^{0})\\[5pt]={}&(7\times 64)+(5\times 8)+(6\times 1)\\[5pt]={}&448+40+6\\[5pt]={}&{\text{decimal }}494\end{aligned}}\qquad {\begin{aligned}&{\text{hex }}\mathrm {3b2} \\[5pt]={}&(3\times 16^{2})+(11\times 16^{1})+(2\times 16^{0})\\[5pt]={}&(3\times 256)+(11\times 16)+(2\times 1)\\[5pt]={}&768+176+2\\[5pt]={}&{\text{decimal }}946\end{aligned}}}](https://wikimedia.org/api/rest_v1/media/math/render/svg/085edfdae3459f4be2506671e2c93394a23db200)
Representar fracciones en binario editar
Números de coma fija editar
El formato de coma fija puede resultar útil para representar fracciones en binario.
El número de bits necesarios para la precisión y el rango deseados se deben elegir para almacenar las partes fraccionarias y enteras de un número. Por ejemplo, si se usa un formato de 32 bits, se pueden usar 16 bits para el número entero y 16 para la fracción.
El bit de ocho es seguido por el bit de cuatro, luego el bit de dos y luego el bit de uno. Los bits fraccionarios continúan el patrón establecido por los bits enteros. El siguiente bit es el bit de la mitad, luego el bit de un cuarto, luego el bit de ⅛, y así sucesivamente. Por ejemplo:
| bits parte entera | bits parte fraccionaria | ||||
|---|---|---|---|---|---|
| 0.500 | = | 12 | = | 00000000 00000000.10000000 00000000 | |
| 1.250 | = | 114 | = | 00000000 00000001.01000000 00000000 | |
| 7.375 | = | 738 | = | 00000000 00000111.01100000 00000000 | |
Esta forma de codificación no puede representar algunos valores en binario. Por ejemplo, la fracción 15, 0.2 en decimal, las aproximaciones más cercanas serían las siguientes:
| 13107 / 65536 | = | 00000000 00000000.00110011 00110011 | = | 0.1999969... en decimal |
| 13108 / 65536 | = | 00000000 00000000.00110011 00110100 | = | 0.2000122... en decimal |
Incluso si se utilizan más dígitos, es imposible una representación exacta. El número 13, escrito en decimal como 0.333333333 ..., continúa indefinidamente. Si se termina prematuramente, el valor no representaría 13 con precisión.
Números de coma flotante editar
Si bien los enteros con signo y sin signo se utilizan en los sistemas digitales, incluso un entero de 32 bits no es suficiente para manejar todo el rango de números que puede manejar una calculadora, y eso ni siquiera incluye fracciones. Para aproximar con mayor rango y precisión los números reales, se tienen que abandonar los enteros con signo y los números de coma fija y pasar a un formato de "coma flotante".
En el sistema decimal, son familiares los números con coma flotante de la forma (notación científica):
- 1.1030402 × 105 = 1.1030402 × 100000 = 110304.02
o, de forma más compacta:
- 1.1030402E5
lo que significa "1.1030402 por 1 seguido de 5 ceros". Se tiene un cierto valor numérico (1,1030402) conocido como "mantisa", multiplicado por una potencia de 10 (E5, que significa 105 o 100.000), conocida como "exponente". Si se tiene un exponente negativo, esto significa que el número se multiplica por un "1", colocado tantos lugares a la derecha del punto decimal. Por ejemplo:
- 2.3434E − 6 = 2.3434 × 10−6 = 2.3434 × 0.000001 = 0.0000023434
La ventaja de esta notación es que al usar el exponente se puede obtener un rango de números mucho más amplio, incluso si el número de dígitos en el significado, o la "precisión numérica", es mucho menor que el rango.
Se pueden definir formatos de coma flotante binarios similares para computadoras. Existe una serie de disposiciones de este tipo. La más popular ha sido definida por el Institute of Electrical and Electronics Engineers (IEEE). La especificación estándar IEEE 754-2008 define un formato de punto flotante de 64 bits con:
- Un exponente binario de 11 bits, utilizando el formato "exceso-1023". Exceso-1023 significa que el exponente aparece como un entero binario sin signo de 0 a 2047; restar 1023 da el valor real con signo
- Un significado de 52 bits, también un número binario sin signo, que define un valor fraccionario con un "1" implícito a la izquierda
- Un bit de signo, dando el signo del número.
Se muestra a continuación cómo se almacenaría un número en 8 bytes de memoria con este formato:
| byte 0 | S | x10 | x9 | x8 | x7 | x6 | x5 | x4 |
|---|---|---|---|---|---|---|---|---|
| byte 1 | x3 | x2 | x1 | x0 | m51 | m50 | m49 | m48 |
| byte 2 | m47 | m46 | m45 | m44 | m43 | m42 | m41 | m40 |
| byte 3 | m39 | m38 | m37 | m36 | m35 | m34 | m33 | m32 |
| byte 4 | m31 | m30 | m29 | m28 | m27 | m26 | m25 | m24 |
| byte 5 | m23 | m22 | m21 | m20 | m19 | m18 | m17 | m16 |
| byte 6 | m15 | m14 | m13 | m12 | m11 | m10 | m9 | m8 |
| byte 7 | m7 | m6 | m5 | m4 | m3 | m2 | m1 | m0 |
donde "S" denota el bit de signo, "x" denota un bit de exponente y "m" denota un bit del significando. Una vez que se han extraído los bits de aquí, se convierten con el cálculo siguiente:
- <signo> × (1 + <significando fraccionario>) × 2<exponente> − 1023
Este sistema proporciona cifras válidas hasta aproximadamente 15 dígitos decimales, con el siguiente rango de números:
| máximo | mínimo | |
|---|---|---|
| positivo | 1.797693134862231E+308 | 4.940656458412465E-324 |
| negativo | -4.940656458412465E-324 | -1.797693134862231E+308 |
La especificación también define varios valores especiales que no son números definidos, y se conocen como NaNs (abreviatura de "Not a Number", "No Un Número"), utilizados por programas para designar operaciones no válidas y similares.
Algunos programas también utilizan números de coma flotante de 32 bits. El esquema más común utiliza un significando de 23 bits con un bit de signo, más un exponente de 8 bits en formato "exceso-127", dando siete dígitos decimales válidos.
| byte 0 | S | x7 | x6 | x5 | x4 | x3 | x2 | x1 |
|---|---|---|---|---|---|---|---|---|
| byte 1 | x0 | m22 | m21 | m20 | m19 | m18 | m17 | m16 |
| byte 2 | m15 | m14 | m13 | m12 | m11 | m10 | m9 | m8 |
| byte 3 | m7 | m6 | m5 | m4 | m3 | m2 | m1 | m0 |
Los bits se convierten a un valor numérico con el cálculo:
- <signo> × (1 + <significado fraccionario>) × 2<exponente> − 127
lo que lleva al siguiente rango de números:
| máximo | mínimo | |
|---|---|---|
| positivo | 3.402823E+38 | 2.802597E-45 |
| negativo | -2.802597E-45 | -3.402823E+38 |
Estos números de punto flotante se conocen como "reales" o "flotantes" en general, pero con una serie de variaciones:
Un valor flotante de 32 bits a veces se denomina "real32" o "único", que significa "valor de coma flotante de precisión simple".
Un flotante de 64 bits a veces se denomina "real64" o "doble", que significa "valor de coma flotante de doble precisión".
La relación entre números y patrones de bits se elige por conveniencia en la manipulación por computadora; ocho bytes almacenados en la memoria de la computadora pueden representar un real de 64 bits, dos reales de 32 bits o cuatro enteros con o sin signo, o algún otro tipo de datos que quepan en ocho bytes. La única diferencia es cómo los interpreta la computadora. Si la computadora almacena cuatro enteros sin firmar y luego los vuelve a leer de la memoria como un número real de 64 bits, casi siempre sería un número real perfectamente válido, aunque serían datos basura.
Solo se puede representar un rango finito de números reales con un número dado de bits. Las operaciones aritméticas pueden desbordarse o desbordarse, produciendo un valor demasiado grande o demasiado pequeño para ser representado.
La representación tiene una precisión limitada. Por ejemplo, solo se pueden representar 15 dígitos decimales con un real de 64 bits. Si se agrega un número de coma flotante muy pequeño a uno grande, el resultado es solo el grande. El número pequeño era demasiado pequeño para aparecer incluso en 15 o 16 dígitos de resolución, y la computadora lo descarta en la práctica. Analizar el efecto de la precisión limitada es un problema bien estudiado. Las estimaciones de la magnitud de los errores de redondeo y los métodos para limitar su efecto en grandes cálculos son parte de cualquier gran proyecto de cálculo. El límite de precisión es diferente del límite de rango, ya que afecta al significando, no al exponente.
El significando es una fracción binaria que no necesariamente coincide perfectamente con una fracción decimal. En muchos casos, una suma de potencias recíprocas de 2 no coincide con una fracción decimal específica, y los resultados de los cálculos estarán ligeramente desviados. Por ejemplo, la fracción decimal "0.1" es equivalente a una fracción binaria que se repite infinitamente: 0.000110011 ...[7]
Números en lenguajes de programación editar
La programación en lenguaje ensamblador requiere que el programador realice un seguimiento de la representación de los números. Cuando el procesador no admite una operación matemática requerida, el programador debe elaborar un algoritmo y una secuencia de instrucciones adecuados para llevar a cabo la operación; en algunos microprocesadores, incluso la multiplicación de números enteros debe realizarse en el software.[8]
Los lenguaje de programación de alto nivel, como Ruby y Python, ofrecen un número abstracto que puede ser de tipo expandido, como "racional", "bignum" o "complejo". Las operaciones matemáticas se llevan a cabo mediante rutinas de biblioteca proporcionadas por la implementación del lenguaje.[9] Un símbolo matemático dado en el código fuente, a través de la gestión del posible desbordamiento del operador, invocará un código de objeto diferente apropiado para la representación del tipo numérico. Las operaciones matemáticas sobre cualquier número, ya sea con signo, sin signo, racional, de coma flotante, de coma fija, entero o complejo, se escriben exactamente de la misma manera.
Algunos idiomas, como REXX y Java, proporcionan operaciones de coma flotante decimal, que tratan los errores de redondeo de una forma diferente.[10]
Véase también editar
Referencias editar
- ↑ a b
Jon Stokes (2017). Inside the machine: an illustrated introduction to microprocessors and computer architecture. No Starch Press. p. 66. ISBN .(978-1-59327-104-6)
|isbn=incorrecto (ayuda). - ↑ «byte definition». Consultado el 24 de abril de 2012.
- ↑ Frédéric Drouillon (2012). De C a C++: de la programación procedural al objeto. Ediciones ENI. pp. 50 de 604. ISBN 9782746078444. Consultado el 9 de julio de 2021.
- ↑ «Microprocessor and CPU (Central Processing Unit)». Network Dictionary. Archivado desde el original el 3 de octubre de 2017. Consultado el 1 de mayo de 2012.
- ↑ «nybble definition». Consultado el 3 de mayo de 2012.
- ↑ «Nybble». TechTerms.com. Consultado el 3 de mayo de 2012.
- ↑ Goebel, Greg. «Computer Numbering Format». Consultado el 10 de septiembre de 2012.
- ↑ QUERO CATALINAS, ENRIQUE (2002). Sistemas operativos y lenguajes de programación. Editorial Paraninfo. pp. 128 de 288. ISBN 9788497321501. Consultado el 9 de julio de 2021.
- ↑ Jonathan S. Walker (2018). Python: La Guía Definitiva para Principiantes para Dominar Python. Babelcube Inc. p. 35. ISBN 9781547539222. Consultado el 9 de julio de 2021.
- ↑ Harvey M. Deitel, Paul J. Deitel (2003). Cómo programar en Java. Pearson Educación. pp. 46 de 1325. ISBN 9789702605188. Consultado el 9 de julio de 2021.
Datos: Q111737392
