3.3: Extendiendo enteros, el tipo BigInt
- Page ID
- 113363
\( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)
\( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)
\( \newcommand{\id}{\mathrm{id}}\) \( \newcommand{\Span}{\mathrm{span}}\)
( \newcommand{\kernel}{\mathrm{null}\,}\) \( \newcommand{\range}{\mathrm{range}\,}\)
\( \newcommand{\RealPart}{\mathrm{Re}}\) \( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)
\( \newcommand{\Argument}{\mathrm{Arg}}\) \( \newcommand{\norm}[1]{\| #1 \|}\)
\( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\)
\( \newcommand{\Span}{\mathrm{span}}\)
\( \newcommand{\id}{\mathrm{id}}\)
\( \newcommand{\Span}{\mathrm{span}}\)
\( \newcommand{\kernel}{\mathrm{null}\,}\)
\( \newcommand{\range}{\mathrm{range}\,}\)
\( \newcommand{\RealPart}{\mathrm{Re}}\)
\( \newcommand{\ImaginaryPart}{\mathrm{Im}}\)
\( \newcommand{\Argument}{\mathrm{Arg}}\)
\( \newcommand{\norm}[1]{\| #1 \|}\)
\( \newcommand{\inner}[2]{\langle #1, #2 \rangle}\)
\( \newcommand{\Span}{\mathrm{span}}\) \( \newcommand{\AA}{\unicode[.8,0]{x212B}}\)
\( \newcommand{\vectorA}[1]{\vec{#1}} % arrow\)
\( \newcommand{\vectorAt}[1]{\vec{\text{#1}}} % arrow\)
\( \newcommand{\vectorB}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)
\( \newcommand{\vectorC}[1]{\textbf{#1}} \)
\( \newcommand{\vectorD}[1]{\overrightarrow{#1}} \)
\( \newcommand{\vectorDt}[1]{\overrightarrow{\text{#1}}} \)
\( \newcommand{\vectE}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash{\mathbf {#1}}}} \)
\( \newcommand{\vecs}[1]{\overset { \scriptstyle \rightharpoonup} {\mathbf{#1}} } \)
\( \newcommand{\vecd}[1]{\overset{-\!-\!\rightharpoonup}{\vphantom{a}\smash {#1}}} \)
En el Capítulo 8, exploraremos los números primos y es común que superen el máximo permitido Int64 o incluso Int128. Si esto es necesario, existe un tipo llamado BigInt sin máximo ni mínimo. El número googol es el\(10^{100}\) que estos dos tipos enteros no contendrán. Sin embargo, si entramos
que es 1 seguido de 100 ceros es muy grande. Nota: el comando big crea un BigInt y generalmente las operaciones normales con enteros dan como resultado BigInts también. Nota: si crees que hubo un error tipográfico con googol, google “googol”.
Es muy importante entender qué tan grande (10) ^100 funciona. Primero se hace un número de tipo BigInt con un valor de 10. Entonces eso se eleva a la potencia número 100. Como se señaló ear-lier, un BigInt no tiene un límite superior o inferior en el número. Puede crecer según sea necesario.
Intentando entrar grande (10^100) abajo.
El resultado es 0, lo que debería ser sorprendente, sin embargo, tenga en cuenta que por orden de operaciones, primero se calcula 10^100 en Int64 estándar y luego se convierte en un BigInt. Nuevamente, para obtener detalles sobre lo que sucede aquí, mira el Apéndice C, en definitiva esto multiplica continuamente el número diez, 100 veces lo que resulta en desbordamiento y como tal da como resultado 0.
Se recomienda usar solo un BigInt si es necesario. Como veremos en el capítulo 8, las operaciones con ellos son significativamente más lentas que Int64 o incluso Int128. Bajo pocos casos necesitas hacer esto. Por ejemplo, en ese capítulo posterior con números primos.
El tipo de datos BigFloat
Revisemos un ejemplo de la sección XXXX y sumemos 1/9 nueve veces. Recordemos que
que muestra la limitación del tipo de punto flotante. El tipo de datos BigFloat es más flexible. Sin embargo, tenga en cuenta que
que parece tener una precisión de sólo 17 dígitos, lo que es típico de un punto flotante de 64 bits, por lo que no parece haber mejorado nada. Esto, como arriba, es un caso de tener cuidado en la construcción de un BigFloat. ¿Qué pasa con big (1/9)? Ponte tu sombrero de orden de operaciones y echa un vistazo. El 1/9 se hace primero y dado que tanto 1 como 9 son enteros regulares (Int64), el resultado es un Float64. Entonces la función grande convierte al Float64 en un BigFloat, pero no nosotros la precisión esperada.
En cambio, si definimos
que se parece más a un resultado esperado. Para determinar el número de dígitos de precisión, puede contar (dolorosamente) o intentar
que es aproximadamente 5 veces la precisión de Float64. Nota: mirando de nuevo el orden de las operaciones, la Después trabajando dentro a afuera, encuentra la longitud de la cuerda.longitud del comando (string (a)) primero toma el número a y lo devuelve como una String.
La función de precisión utilizada en una variable de tipo BigFloat indicará la precisión de la variable. Así
que es el número de bits de precisión y tiene 4 veces la precisión binaria de Float64 pero aproximadamente 5 veces la precisión decimal.
Sin embargo, como se señaló al inicio de esta sección, si queremos calcular\(\pi\) a 1 millón de dígitos decimales, lo que hemos visto hasta ahora solo tiene aproximadamente 80 dígitos de precisión. Como un poco tentador, lo haremos en el Capítulo XXX.
El tipo BigFloat es bastante flexible. El ejemplo anterior lo utilizó en su precisión predeterminada. Podemos cambiar esto con la función setprecision. Por ejemplo:
mostrando que ahora BigFloats se almacenará en tantos bits. Tal número utilizará 16 veces el número de dígitos binarios como un Float64. Entrando
un número que, de un vistazo, busca almacenar aproximadamente 4 veces el número de dígitos como el tamaño predeterminado de BigFloat. Para determinar el número total de dígitos decimales, si ingresamos
como el número de dígitos decimales. Esto es aproximadamente 20 veces la precisión de Float64.