Wolfram Language es compatible con tres tipos de aritmética computacional:

• Aritmética de precisión mecánica
• Aritmética de precisión arbitraria
• Aritmética de precisión infinita

Cada una cuenta con sus respectivos beneficios y debilidades, y comprender cuando utilizar cada una de ellas para obtener los resultados más rápidos y precisos es una parte importante de programar con Wolfram Language. El objetivo de este artículo es proporcionar una perspectiva general de cada tipo sin profundizar en los detalles técnicos. Puede encontrar detalles adicionales en la documentación de Wolfram Language, y proporcionaremos enlaces a lo largo del artículo.

Aritmética de precisión mecánica

La aritmética de precisión mecánica se utiliza cuando un número es ingresado con un punto decimal (por ejemplo 4.2 o 1.), o cuando se utiliza la función de argumento individual N (por ejemplo N[1/2]). En la mayoría de equipos modernos, la aritmética de precisión mecánica resulta en alrededor de 16 dígitos de mantisa (los dígitos que siguen al punto decimal).

La principal ventaja de la aritmética de precisión mecánica es su velocidad. Los cálculos numéricos de precisión arbitraria generalmente son muchas veces más lentos que los cálculos de precisión mecánica.

Si bien la computación de precisión mecánica es rápida, debe evitarse al trabajar con números muy altos o muy bajos para los cuales la precisión es crítica (use la precisión arbitraria en su lugar), o cuando se necesita un resultado simbólico (use la precisión infinita en su lugar).

Cabe mencionar que los errores de redondeo no son monitoreados al usar la precisión mecánica. Esto se hace por velocidad, pero puede generar resultados erróneos. Por ejemplo, Out[1] es incorrecto en el siguiente ejemplo:

In[1]:= N[Sin[10^50]]
Out[1]= -0.4805

In[2]:= N[Sin[10^50], 20]
Out[2]= -0.78967249342931008271

La mayoría de las funciones matemáticas integradas de Wolfram Language proporcionan salidas que se adecúan más a la precisión de las entradas determinadas. Si proporciona una entrada de precisión mecánica a estas funciones, resultarán en una salida de precisión mecánica. Por ejemplo:

In[3]:= Sin[4.2]
Out[3]= -0.871576

In[4]:= Precision[%]
Out[4]= MachinePrecision

De manera similar, si combina entradas de precisión mecánica con entradas de precisión arbitraria o infinita en un solo cálculo, el resultado será proporcionado en precisión mecánica:

In[5]:= 3 + 4.5
Out[5]= 7.5

In[6]:= Precision@%
Out[6]= MachinePrecision

Los operadores numéricos (NIntegrate, NSum, NDSolve, etc.) devuelven precisión mecánica de manera predeterminada.

Aritmética de precisión arbitraria

Al realizar cálculos con números de aritmética de precisión arbitraria, Wolfram Language monitorea la precisión en todo momento. Por lo general Wolfram Language intenta proporcionarle resultados con la mayor precisión posible, dada la precisión de la entrada que usted proporcionó.

Los números de precisión arbitraria son creados más frecuentemente utilizando la función N con su segundo argumento. Por ejemplo, N[Pi, 20] proporciona el resultado numérico de Pi a 20 dígitos de precisión (3.1415926535897932385).

La precisión arbitraria resulta útil para cálculos que requieren un alto grado de precisión, incluido el trabajo con números muy altos o muy bajos. Sin embargo, los cómputos de precisión arbitraria son más lentos que los cálculos de precisión mecánica, de manera que los números de precisión arbitraria por lo general no son utilizados cuando no se requiere un alto grado de precisión.

Al igual que con los números de precisión mecánica, si proporciona una entrada de precisión arbitraria a funciones matemáticas integradas, resultarán en una salida de precisión arbitraria. Por ejemplo:

In[1]:= N[7, 30]^2
Out[1]= 49.0000000000000000000000000000

In[2]:= Precision[%]
Out[2]= 29.699

Si combina entradas de precisión mecánica y arbitraria, el resultado será en una salida de precisión mecánica. Por ende, los errores no serán monitoreados.

Una manera efectiva de evaluar una expresión en precisión arbitraria es usar SetPrecision:

In[3]:= SetPrecision[1.9658*(1.23423423/500 + 600/3.9879), 20]
Out[3]= 295.76954069704845551

Puede forzar a operadores numéricos (NIntegrate, NSum, NDSolve, etc.) a usar la precisión arbitraria configurando su opción WorkingPrecision.

Aritmética de precisión infinita

La aritmética de precisión infinita se utiliza cuando se conocen las entradas exactas y se desea obtener salidas exactas, o al manipular expresiones de manera algebraica.

La función Rationalize es útil para convertir números de punto flotante a un número exacto.

Si proporciona una entrada de precisión infinita a las funciones matemáticas integradas, el resultado será una salida de precisión infinita. Por ejemplo:

In[1]:= Cos[Pi]
Out[1]= -1

In[2]:= Precision[%]
Out[2]= \[Infinity]

Si combina entradas de precisión infinita y mecánica, el resultado será una salida de precisión mecánica.

[English]