A Wolfram Language suporta três tipos de aritmética computacional:

• Aritmética de precisão da máquina
• Aritmética de precisão arbitrária
• Aritmética de precisão infinita

Cada um tem seus respectivos benefícios e pontos fracos, e compreender quando usá-los para obter resultados mais rápidos e precisos é uma parte importante da caixa de ferramentas de qualquer programador da Wolfram Language. Este artigo tem como objetivo fornecer uma visão geral de cada tipo sem se aprofundar em todas as especificações técnicas. Mais detalhes podem ser encontrados na documentação da Wolfram Language, os links estarão disponíveis nesta página.

Aritmética de precisão da máquina

Aritmética de precisão da máquina é usado quando um número é inserido com um ponto decimal (por exemplo, 4.2 ou 1.) ou quando a função N de argumento único é usada (por exemplo, N[1/2]). Na maioria dos computadores modernos, a aritmética de precisão da máquina resulta em aproximadamente 16 dígitos de mantissa (dígitos após o ponto decimal).

A principal vantagem do uso da aritmética de precisão da máquina é a velocidade. Os cálculos numéricos de precisão arbitrária são geralmente mais lentos que os cálculos de precisão da máquina.

Apesar do cálculo da precisão da máquina ser rápido, ele deve ser evitado ao trabalhar com números muito grandes ou muito pequenos em que a precisão é crítica (use precisão arbitrária) ou quando for necessário um resultado simbólico (use precisão infinita).

Também é importante notar que, ao usar a precisão da máquina, os erros de arredondamento não são rastreados. Isso é feito com rapidez, mas pode resultar em resultados incorretos. Por exemplo, Out[1] está incorreto a seguir:

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

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

A maioria das funções matemáticas integradas da Wolfram Language fornece resultados que melhor correspondem à precisão da entrada fornecida. Se você alimentar essas funções com uma entrada de precisão da máquina, elas resultarão em uma saída com precisão da máquina. Por exemplo:

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

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

Da mesma forma, se você combinar entradas de precisão da máquina com entradas de precisão arbitrária ou infinita em um único cálculo, o resultado será fornecido com precisão da máquina:

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

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

De forma padrão, os operadores numéricos (NIntegrate, NSum, NDSolve, etc.) retornam os seus resultados com precisão da máquina.

Aritmética de precisão arbitrária

Quando você faz cálculos com números aritméticos de precisão arbitrária, a Wolfram Language mantém o controle da precisão em todos os pontos. Em geral, a Wolfram Language tenta fornecer resultados com a maior precisão possível, dada a precisão da entrada fornecida.

Os números de precisão arbitrária são mais comumente criados usando a função N com seu segundo argumento. Por exemplo, N[Pi, 20] fornece o resultado numérico de Pi com 20 dígitos de precisão (3.1415926535897932385).

A precisão arbitrária é útil para cálculos que exigem um alto grau de precisão, inclusive trabalhando com números muito grandes ou muito pequenos. No entanto, os cálculos de precisão arbitrária são mais lentos que os cálculos de precisão da máquina; portanto, os números de precisão arbitrária geralmente não são usados quando não é necessário alta precisão.

Assim como acontece com os números de precisão da máquina, se você alimentar funções matemáticas incorporadas como uma entrada de precisão arbitrária, elas resultarão em uma saída de precisão arbitrária. Por exemplo:

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

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

Combinar entrada de precisão da máquina e precisão arbitrária resultará em uma saída da precisão da máquina. Como resultado, os erros não serão rastreados.

Uma maneira eficaz de avaliar uma expressão com precisão arbitrária é usar SetPrecision:

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

Você pode forçar operadores numéricos (NIntegrate, NSum, NDSolve, etc.) a usar precisão arbitrária definindo sua opção WorkingPrecision.

Aritmética de precisão infinita

A aritmética de precisão infinita é usada quando entradas exatas são conhecidas e saídas exatas são desejadas ou ao manipular expressões algebricamente.

Rationalize é uma função útil para converter números de ponto flutuante em um número exato.

Se você alimentar funções matemáticas integradas com uma entrada de precisão infinita, elas resultarão em uma saída de precisão infinita. Por exemplo:

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

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

Combinar entrada de precisão infinita e precisão da máquina resultará em uma saída de precisão da máquina.

[English]