Funções trigonométricas em C++

O C++ oferece funções de seno, cosseno, tangente, trigonométricas inversas e hiperbólicas no cabeçalho padrão <cmath>. As funções trigonométricas comuns recebem ângulos em radianos e retornam valores de ponto flutuante. Use os nomes qualificados com std:: para deixar claro que o código se refere à biblioteca padrão.

Use std::sin, std::cos e std::tan para ângulos em radianos

Chame std::sin(angle), std::cos(angle) e std::tan(angle) para calcular o seno, o cosseno e a tangente de um ângulo. Inclua <cmath> para obter suas declarações. Essas funções têm sobrecargas para tipos de ponto flutuante; o resultado usa o tipo de ponto flutuante correspondente (argumentos inteiros são convertidos para uma sobrecarga de ponto flutuante).

Execute este exemplo:

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

#include <cmath>
#include <iomanip>
#include <iostream>

int main() {
  const double angle = 1.0; // radians
  std::cout << std::fixed << std::setprecision(6)
            << "sin(" << angle << ") = " << std::sin(angle) << '\n'
            << "cos(" << angle << ") = " << std::cos(angle) << '\n'
            << "tan(" << angle << ") = " << std::tan(angle) << '\n';
}

A saída observada nesta execução é:

sin(1.000000) = 0.841471
cos(1.000000) = 0.540302
tan(1.000000) = 1.557408

O argumento corresponde a um radiano. std::fixed e std::setprecision(6) formatam cada valor retornado com seis casas decimais.

Use funções trigonométricas inversas para recuperar ângulos

Use std::asin(x) para recuperar um ângulo a partir de um valor de seno, std::acos(x) a partir de um valor de cosseno e std::atan(x) a partir de um valor de tangente. Os resultados são expressos em radianos. asin aceita valores de -1 a 1 e retorna um ângulo em [-π/2, π/2]; acos aceita o mesmo intervalo de entrada e retorna um ângulo em [0, π]. atan aceita qualquer valor real finito e retorna um ângulo em (-π/2, π/2).

Para obter a direção descrita por duas coordenadas, use std::atan2(y, x). Ao contrário de atan(y / x), essa função considera os sinais dos dois argumentos para determinar o quadrante e não exige que você divida as coordenadas antes. O resultado é um ângulo em radianos, geralmente no intervalo [-π, π] (a representação exata do extremo pode depender da entrada de zero com sinal).

As funções inversas retornam um ângulo principal, não todos os ângulos que poderiam ter produzido o valor original. Por exemplo, vários ângulos podem ter o mesmo seno, então asin, por si só, não consegue recuperar o ângulo original fora de seu intervalo principal. Ao escolher o ângulo final, considere a geometria do problema e as informações sobre o quadrante.

Use funções hiperbólicas para valores hiperbólicos

As funções std::sinh, std::cosh e std::tanh calculam o seno, o cosseno e a tangente hiperbólicos. Elas são definidas a partir de funções exponenciais e não substituem std::sin, std::cos e std::tan: recebem valores reais, não ângulos em um círculo, e têm intervalos de valores diferentes. Por exemplo, cosh(x) é sempre maior ou igual a 1, enquanto o cosseno comum permanece entre -1 e 1.

As funções hiperbólicas inversas são std::asinh, std::acosh e std::atanh. Seus domínios nos números reais são diferentes: asinh aceita qualquer entrada real, acosh exige uma entrada maior ou igual a 1, e atanh exige uma entrada estritamente entre -1 e 1. Use essas funções para relações hiperbólicas; não basta acrescentar a ao nome de uma função trigonométrica comum.

Trate unidades angulares, domínios e resultados de ponto flutuante

As funções trigonométricas de <cmath> em C++ esperam radianos. Converta graus com radians = degrees * π / 180; por exemplo, 90 graus correspondem a π/2 radianos. Em C++ portátil, obtenha π com std::acos(-1.0) ou defina a constante necessária, pois M_PI não é um nome padrão do C++.

As entradas das funções inversas devem estar dentro de seus domínios nos números reais. Verifique ou limite um valor somente quando isso for compatível com a matemática da aplicação: limitar um valor que ultrapasse ligeiramente [-1, 1] pode compensar erros de arredondamento acumulados, mas não deve ocultar uma entrada realmente fora do intervalo. Um erro de domínio é tratado de acordo com o comportamento da biblioteca matemática do C++ e da implementação; não é comportamento indefinido. Se a aplicação precisar distinguir um resultado válido de um erro matemático, consulte math_errhandling e verifique os indicadores de erro relevantes que a implementação oferece.

std::tan cresce muito perto de múltiplos ímpares de π/2 e não tem valor real finito nesses polos matemáticos. Uma aproximação de ponto flutuante de um polo pode produzir um resultado finito muito grande, em vez de um sinal de erro claro. Portanto, se o comportamento perto de um polo for relevante, avalie a entrada de acordo com as necessidades e a tolerância da aplicação.

Cálculos de ponto flutuante são aproximações. Valores como std::sin(std::acos(-1.0)) podem ser próximos de zero, mas não exatamente iguais a zero. Compare os valores calculados usando uma tolerância adequada à aplicação, em vez de exigir igualdade exata. Use double em cálculos comuns e escolha um tipo mais amplo somente quando precisar da precisão adicional e houver suporte para ele. Prefira a biblioteca padrão a aproximações implementadas manualmente e armazene um valor calculado se for reutilizá-lo.