Como usar a constante PI em C ++

Eu quero usar as funções constantes e trigonométricas do PI em algum programa C ++. Eu recebo as funções trigonométricas com include <math.h>. No entanto, não parece haver uma definição para PI neste arquivo de cabeçalho.

Como posso obter o PI sem defini-lo manualmente?

Em algumas plataformas (especialmente mais antigas) (veja os comentários abaixo), pode ser necessário

#define _USE_MATH_DEFINES

e inclua o arquivo de cabeçalho necessário:

#include <math.h>

e o valor de pi pode ser acessado via:

M_PI

No meu math.h(2014), é definido como:

# define M_PI           3.14159265358979323846  /* pi */

mas verifique o seu math.hpara mais. Um extrato do "antigo" math.h(em 2009):

/* Define _USE_MATH_DEFINES before including math.h to expose these macro
 * definitions for common math constants.  These are placed under an #ifdef
 * since these commonly-defined names are not part of the C/C++ standards.
 */

Contudo:

1. em plataformas mais novas (pelo menos no meu Ubuntu 14.04 de 64 bits), não preciso definir o _USE_MATH_DEFINES

2. Nas plataformas Linux (recentes), existem long doublevalores também fornecidos como uma Extensão GNU:

   # define M_PIl          3.141592653589793238462643383279502884L /* pi */

Pi pode ser calculado como atan(1)*4. Você pode calcular o valor dessa maneira e armazená-lo em cache.

Você também pode usar o boost, que define constantes matemáticas importantes com a máxima precisão para o tipo solicitado (por exemplo, float vs double).

const double pi = boost::math::constants::pi<double>();

Confira a documentação do impulso para mais exemplos.

Obtê-lo da unidade FPU no chip:

double get_PI()
{
    double pi;
    __asm
    {
        fldpi
        fstp pi
    }
    return pi;
}

double PI = get_PI();

Eu recomendaria apenas digitar pi com a precisão que você precisa. Isso não adicionaria tempo de cálculo à sua execução e seria portátil sem o uso de cabeçalhos ou #defines. Calcular acos ou atan é sempre mais caro do que usar um valor pré-calculado.

const double PI  =3.141592653589793238463;
const float  PI_F=3.14159265358979f;

Em vez de escrever

#define _USE_MATH_DEFINES

Eu recomendaria usar -D_USE_MATH_DEFINESou /D_USE_MATH_DEFINESdependendo do seu compilador.

Dessa forma, você tem certeza de que, mesmo no caso de alguém incluir o cabeçalho antes de você (e sem o #define), você ainda terá as constantes, em vez de um erro obscuro do compilador, que levará anos para rastrear.

Como a biblioteca padrão oficial não define um PI constante, você precisa defini-lo. Portanto, a resposta para sua pergunta "Como posso obter o PI sem defini-lo manualmente?" é "Você não precisa - ou confia em algumas extensões específicas do compilador.". Se você não está preocupado com a portabilidade, consulte o manual do seu compilador.

C ++ permite escrever

const double PI = std::atan(1.0)*4;

mas não é garantido que a inicialização dessa constante seja estática. No entanto, o compilador G ++ lida com essas funções matemáticas como intrínsecas e é capaz de calcular essa expressão constante em tempo de compilação.

Na página do manual Posix de math.h :

   The  <math.h>  header  shall  provide for the following constants.  The
   values are of type double and are accurate within the precision of  the
   double type.

   M_PI   Value of pi

   M_PI_2 Value of pi/2

   M_PI_4 Value of pi/4

   M_1_PI Value of 1/pi

   M_2_PI Value of 2/pi

   M_2_SQRTPI
          Value of 2/ sqrt pi

C ++ 20 std::numbers::pi

Finalmente chegou: http://eel.is/c++draft/numbers

Espero que o uso seja como:

#include <numbers>
#include <iostream>

int main() {
    std::cout << std::numbers::pi << std::endl;
}

Vou tentar quando o suporte chegar ao GCC, o GCC 9.1.0 com g++-9 -std=c++2aainda não o suporta.

A proposta aceita descreve:

5.0 “Cabeçalhos” [cabeçalhos] Na tabela [guia: cpp.library.headers], um novo<math> cabeçalho precisa ser adicionado.

[...]

namespace std {
namespace math { 
  template<typename T > inline constexpr T pi_v = unspecified;
    inline constexpr double pi = pi_v<double>;

Há também um std::numbers::e claro :-) Como calcular a constante de Euler ou a alimentação de Euler em C ++?

Essas constantes usam o recurso de modelo de variável C ++ 14: C ++ 14: Modelos de variável C ++ 14: qual é o seu objetivo? Algum exemplo de uso?

Nas versões anteriores do rascunho, a constante estava em std::math::pi: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0631r7.pdf

O C ++ padrão não tem uma constante para o PI.

Muitos compiladores C ++ definem M_PIin cmath(ou in math.hfor C) como uma extensão não padrão. Você pode precisar fazer isso #define _USE_MATH_DEFINESantes de poder vê-lo.

eu faria

template<typename T>
T const pi = std::acos(-T(1));

ou

template<typename T>
T const pi = std::arg(-std::log(T(2)));

Eu não digitaria π com a precisão que você precisa . O que isso quer dizer? A precisão de que você precisa é a precisão T, mas não sabemos nada sobreT .

Você pode dizer: Do que você está falando? Tserá float, doubleou long double. Então, basta digitar a precisão de long double, ie

template<typename T>
T const pi = static_cast<T>(/* long double precision π */);

Mas você realmente sabe que no futuro não haverá um novo tipo de ponto flutuante com uma precisão ainda mais alta do que long double ? Você não

E é por isso que a primeira solução é linda. Você pode ter certeza de que o padrão sobrecarregaria as funções trigonométricas para um novo tipo.

E, por favor, não diga que a avaliação de uma função trigonométrica na inicialização é uma penalidade de desempenho.

Eu uso o seguinte em um dos meus cabeçalhos comuns no projeto que abrange todas as bases:

#define _USE_MATH_DEFINES
#include <cmath>

#ifndef M_PI
#define M_PI (3.14159265358979323846)
#endif

#ifndef M_PIl
#define M_PIl (3.14159265358979323846264338327950288)
#endif

Em uma nota lateral, todos os compiladores abaixo definem constantes M_PI e M_PIl se você incluir <cmath>. Não há necessidade de adicionar `#define _USE_MATH_DEFINES, que é necessário apenas para o VC ++.

x86 GCC 4.4+
ARM GCC 4.5+
x86 Clang 3.0+

Geralmente, prefiro definir o meu: const double PI = 2*acos(0.0); porque nem todas as implementações fornecem isso para você.

A questão de saber se essa função é chamada em tempo de execução ou estática em tempo de compilação geralmente não é um problema, porque só acontece uma vez.

Acabei de encontrar este artigo de Danny Kalev, que tem uma ótima dica para C ++ 14 e superior.

template<typename T>
constexpr T pi = T(3.1415926535897932385);

Achei isso muito legal (embora eu usasse o PI de maior precisão possível), principalmente porque os modelos podem usá-lo com base no tipo.

template<typename T>
T circular_area(T r) {
  return pi<T> * r * r;
}
double darea= circular_area(5.5);//uses pi<double>
float farea= circular_area(5.5f);//uses pi<float>

Valores como M_PI, M_PI_2, M_PI_4, etc não são C ++ padrão, portanto, um constexpr parece uma solução melhor. Diferentes expressões const podem ser formuladas para calcular o mesmo pi e me preocupa se elas (todas) me fornecem a precisão total. O padrão C ++ não menciona explicitamente como calcular pi. Portanto, eu tendem a voltar a definir pi manualmente. Gostaria de compartilhar a solução abaixo, que suporta todos os tipos de frações de pi com total precisão.

#include <ratio>
#include <iostream>

template<typename RATIO>
constexpr double dpipart()
{
    long double const pi = 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899863;
    return static_cast<double>(pi * RATIO::num / RATIO::den);
}

int main()
{
    std::cout << dpipart<std::ratio<-1, 6>>() << std::endl;
}

No windows (cygwin + g ++), achei necessário adicionar a flag -D_XOPEN_SOURCE=500para o pré-processador processar a definição de M_PIin math.h.

C ++ 14 permite que você faça static constexpr auto pi = acos(-1);

Algumas soluções elegantes. Duvido que a precisão das funções trigonométricas seja igual à precisão dos tipos. Para aqueles que preferem escrever um valor constante, isso funciona para g ++: -

template<class T>
class X {
public:
            static constexpr T PI = (T) 3.14159265358979323846264338327950288419\
71693993751058209749445923078164062862089986280348253421170679821480865132823066\
47093844609550582231725359408128481117450284102701938521105559644622948954930381\
964428810975665933446128475648233786783165271201909145648566923460;
...
}

A precisão de 256 dígitos decimais deve ser suficiente para qualquer tipo futuro longo, longo e longo. Se mais forem necessárias, visite https://www.piday.org/million/ .

#include <cmath>
const long double pi = acos(-1.L);

Você consegue fazer isso:

#include <cmath>
#ifndef M_PI
#define M_PI (3.14159265358979323846)
#endif

Se M_PIjá estiver definido cmath, isso não fará nada além de incluir cmath. Se M_PInão estiver definido (como é o caso, por exemplo, no Visual Studio), ele será definido. Nos dois casos, você pode usar M_PIpara obter o valor de pi.

Esse valor de pi vem do qmath.h do Qt Creator.

Você pode usar isso:

#define _USE_MATH_DEFINES // for C++
#include <cmath>

#define _USE_MATH_DEFINES // for C
#include <math.h>

As constantes matemáticas não são definidas no padrão C / C ++. Para usá-los, você deve primeiro definir _USE_MATH_DEFINESe incluir cmathou math.h.