Operadores Aritméticos

Este tópico descreve os operadores aritméticos disponíveis em F#.

Resumo dos operadores aritméticos binários

As operações aritméticas em F# podem ser realizadas em dois modos: Sem verificação e Com verificação. Por padrão, as operações aritméticas utilizam um comportamento não controlado, que prioriza o desempenho, mas permite transbordo/subfluxo. Os operadores verificados dão prioridade à segurança, lançando exceções nesses casos.

Operadores aritméticos não verificados

A tabela a seguir resume os operadores binários de aritmética que estão disponíveis para a Aritmética Não Verificada com tipos integrais e de ponto flutuante não encaixotados.

Operador binário	Observações
+ (adição, mais)	Desmarcado. Possível condição de estouro quando os números são adicionados e a soma excede o valor absoluto máximo suportado pelo tipo.
- (subtração, menos)	Desmarcado. Possível condição de subfluxo quando tipos não assinados são subtraídos ou quando os valores de vírgula flutuante são muito pequenos para serem representados pelo tipo.
* (multiplicação, vezes)	Desmarcado. Possível condição de excesso quando os números são multiplicados e o resultado do produto excede o valor absoluto máximo suportado pelo tipo.
/ (divisão, dividida por)	A divisão por zero causa um DivideByZeroException para tipos inteiros. Para tipos de vírgula flutuante, a divisão por zero dá-lhe os valores especiais de vírgula flutuante infinity ou -infinity. Há também uma possível condição de subfluxo quando um número de vírgula flutuante é muito pequeno para ser representado pelo tipo.
% (restante, rem)	Retorna o restante de uma operação de divisão. O sinal do resultado é o mesmo que o sinal do primeiro operando.
** (exponenciação, ao poder de)	Possível condição de transbordo quando o resultado excede o valor absoluto máximo para o tipo. O operador de exponenciação funciona apenas com tipos de ponto flutuante.

O comportamento não verificado não lança exceções quando ocorre estouro ou subfluxo, tornando-o menos seguro para aritmética em valores grandes ou extremos.

Operadores aritméticos verificados

A tabela a seguir resume os operadores aritméticos binários que estão disponíveis para Aritmética Verificada com tipos integrais não encaixotados. Os operadores verificados garantem que os cálculos sejam verificados quanto a transbordamento ou subfluxo, fornecendo aritmética mais segura para aplicações críticas.

Operador binário	Observações
+ (adição, mais)	Lança uma OverflowException se o resultado exceder o valor máximo ou for inferior ao valor mínimo suportado pelo tipo. Tanto Overflow quanto Underflow são possíveis.
- (subtração, menos)	Lança uma OverflowException se o resultado exceder o valor máximo ou for inferior ao valor mínimo suportado pelo tipo. Tanto Overflow quanto Underflow são possíveis.
* (multiplicação, vezes)	Lança um OverflowException se o produto exceder o valor máximo ou ficar abaixo do valor mínimo suportado pelo tipo. Tanto Overflow quanto Underflow são possíveis.

Os operadores verificados são úteis para garantir que os excessos aritméticos são detetados e tratados explicitamente.

Aqui está um exemplo:

open Microsoft.FSharp.Core.Operators.Checked

let safeAddition () =
    try
        let result = 2147483647 + 1 // Attempt to add integers at their maximum boundary
        printfn "Result: %d" result
    with
    | :? System.OverflowException as ex ->
        printfn "Overflow occurred: %s" ex.Message

safeAddition()

// Output:
// Overflow occurred: Arithmetic operation resulted in an overflow.

Escolhendo entre operadores verificados e não verificados

Operadores verificados: Ideal para cenários em que erros de overflow devem ser detetados e tratados explicitamente.

Operadores não verificados: Por padrão, o F# usa aritmética não verificada por motivos de desempenho. Essas operações podem produzir silenciosamente resultados incorretos quando ocorre transbordamento ou subfluxo. Use com cuidado.

Resumo dos Operadores Aritméticos Unários

A tabela a seguir resume os operadores aritméticos unários que estão disponíveis para tipos integrais e de vírgula flutuante.

Operador unário	Observações
+ (positivo)	Pode ser aplicado a qualquer expressão aritmética. Não altera o sinal do valor.
- (negação, negativo)	Pode ser aplicado a qualquer expressão aritmética. Altera o sinal do valor.

O comportamento em estouro ou subfluxo para tipos integrais é envolver. Isso causa um resultado incorreto. O estouro de número inteiro é um problema potencialmente sério que pode contribuir para problemas de segurança quando o software não é escrito para lidar com ele. Se isso for uma preocupação para a sua aplicação, considere usar os operadores verificados em Microsoft.FSharp.Core.Operators.Checked.

Resumo dos operadores de comparação binária

A tabela a seguir mostra os operadores de comparação binários que estão disponíveis para os tipos integral e de vírgula flutuante. Esses operadores retornam valores do tipo bool.

Números de ponto flutuante nunca devem ser comparados diretamente para igualdade, porque a representação de ponto flutuante IEEE não suporta uma operação de igualdade exata. Dois números que você pode verificar facilmente como iguais inspecionando o código podem, na verdade, ter representações de bits diferentes.

Operador	Observações
= (igualdade, igual)	Este não é um operador de atribuição. É usado apenas para comparação. Este é um operador genérico.
> (maior que)	Este é um operador genérico.
< (inferior a)	Este é um operador genérico.
>= (maior ou igual)	Este é um operador genérico.
<= (menor ou igual)	Este é um operador genérico.
<> (não igual)	Este é um operador genérico.

Operadores sobrecarregados e genéricos

Todos os operadores discutidos neste tópico são definidos no namespace Microsoft.FSharp.Core.Operators . Alguns dos operadores são definidos usando parâmetros de tipo resolvidos estaticamente. Isso significa que existem definições individuais para cada tipo específico que trabalha com esse operador. Todos os operadores aritméticos e à nível de bits unários e binários estão nesta categoria. Os operadores de comparação são genéricos e, portanto, trabalham com qualquer tipo, não apenas com tipos aritméticos primitivos. Os tipos de união e registro discriminados têm suas próprias implementações personalizadas que são geradas pelo compilador F#. Os tipos de classe usam o método Equals.

Os operadores genéricos são personalizáveis. Para personalizar as funções de comparação, substitua Equals para fornecer sua própria comparação de igualdade personalizada e, em seguida, implemente IComparable. A interface System.IComparable tem um único método, o método CompareTo.

Operadores e inferência de tipo

O uso de um operador em uma expressão restringe a inferência de tipo sobre esse operador. Além disso, o uso de operadores impede a generalização automática, porque o uso de operadores implica um tipo aritmético. Na ausência de qualquer outra informação, o compilador F# infere int como o tipo de expressões aritméticas. Você pode substituir esse comportamento especificando outro tipo. Assim, os tipos de argumento e o tipo de retorno de function1 no código a seguir são inferidos como int, mas os tipos para function2 são inferidos como float.

// x, y and return value inferred to be int
// function1: int -> int -> int
let function1 x y = x + y

// x, y and return value inferred to be float
// function2: float -> float -> float
let function2 (x: float) y = x + y

Ver também

• Símbolo e Referência do Operador
• Sobrecarga de Operador
• Operadores de Manipulação de Bits
• Operadores Booleanos