P ++ sabiti C ++ ile nasıl kullanılır

Bazı C ++ programında PI sabiti ve trigonometrik fonksiyonları kullanmak istiyorum. Trigonometrik fonksiyonları ile alıyorum include <math.h>. Ancak, bu başlık dosyasında PI için bir tanım yok gibi görünüyor.

Manuel olarak tanımlamaksızın PI'yi nasıl alabilirim?

Bazı (özellikle eski) platformlarda (aşağıdaki yorumlara bakın)

#define _USE_MATH_DEFINES

ve sonra gerekli başlık dosyasını ekleyin:

#include <math.h>

ve pi değerine şu yolla erişilebilir:

M_PI

In my math.h(2014) bu gibi tanımlanır:

# define M_PI           3.14159265358979323846  /* pi */

ama math.hdaha fazlası için kontrol edin . "Eski" den bir alıntı math.h(2009 yılında):

/* 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.
 */

Ancak:

1. daha yeni platformlarda (en azından 64 bit Ubuntu 14.04'ümde) _USE_MATH_DEFINES

2. (Son zamanlarda) Linux platformlarında long doublebir GNU Uzantısı olarak da sağlanan değerler vardır :

   # define M_PIl          3.141592653589793238462643383279502884L /* pi */

Pi olarak hesaplanabilir atan(1)*4. Değeri bu şekilde hesaplayabilir ve önbelleğe alabilirsiniz.

Ayrıca, istenen matematik türü için (örneğin float ve double) maksimum doğrulukla önemli matematik sabitlerini tanımlayan boost kullanabilirsiniz.

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

Check out boost belgelerine Daha fazla örnek için.

Bunun yerine çip üzerindeki FPU biriminden alın:

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

double PI = get_PI();

İhtiyacınız olan hassasiyete sadece pi yazmanızı tavsiye ederim. Bu, yürütmenize hiçbir hesaplama süresi eklemez ve üstbilgi veya # tanım kullanmadan taşınabilir olur. Acos veya atan hesaplamak her zaman önceden hesaplanmış bir değer kullanmaktan daha pahalıdır.

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

Yazmaktan ziyade

#define _USE_MATH_DEFINES

Derleyicinizi kullanmanızı -D_USE_MATH_DEFINESveya /D_USE_MATH_DEFINESderleyicinize bağlı olarak öneririm .

Bu şekilde, üstbilgiyi sizden önce (ve #define içermeyen) içeren bir durumda bile, izlemeniz gereken yaşları alacağınız belirsiz bir derleyici hatası yerine sabitlere sahip olacağınızdan emin olabilirsiniz.

Resmi standart kütüphane sabit bir PI tanımlamadığı için, onu kendiniz tanımlamanız gerekir. Peki "PI'yi manuel olarak tanımlamadan nasıl alabilirim?" "Yapmazsınız - veya derleyiciye özgü bazı uzantılara güvenirsiniz". Taşınabilirlikle ilgili endişeleriniz yoksa, derleyici kılavuzunuzu kontrol edebilirsiniz.

C ++ yazmanıza izin verir

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

ancak bu sabitin başlatılmasının statik olduğu garanti edilmez. Ancak G ++ derleyicisi bu matematik işlevlerini içsel olarak işler ve bu sabit ifadeyi derleme zamanında hesaplayabilir.

Gönderen math.h ait Posix adam sayfası :

   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

Sonunda geldi: http://eel.is/c++draft/numbers

Kullanımın şöyle olmasını bekliyorum:

#include <numbers>
#include <iostream>

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

Destek GCC'ye geldiğinde bunu deneyeceğim, GCC 9.1.0 g++-9 -std=c++2a hala desteklemiyor.

Kabul edilen teklif şunları açıklar:

5.0. “Üstbilgiler” [üstbilgiler] Tabloda [sekme: cpp.library.headers], yeni<math> üstbilgi eklenmesi gerekir.

[...]

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

std::numbers::eElbette bir de var :-) Nasıl Euler sabit veya C + + powered Euler hesaplamak için?

Bu sabitler C ++ 14 değişken şablon özelliğini kullanır: C ++ 14 Değişken Şablonlar: amaçları nedir? Herhangi bir kullanım örneği var mı?

Taslağın daha önceki sürümlerinde, sabit şunun altındaydı std::math::pi: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0631r7.pdf

Standart C ++ 'nın PI için bir sabiti yoktur.

Birçok C ++ derleyicisi M_PI, cmath(veya math.hC için) standart olmayan bir uzantı olarak tanımlar . Bunu #define _USE_MATH_DEFINESgörmeden önce yapmanız gerekebilir .

yapardım

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

veya

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

Ben ediyorum değil ihtiyacınız hassas tt yazarak . Bunun anlamı ne? İhtiyacınız hassas hassas olduğunu T, ama biz hakkında hiçbir şey bilmiyoruzT .

Şunu söyleyebilirsiniz: Neden bahsediyorsun? Tolacak float, doubleya da long double. Yani, sadece hassasiyetini yazın long double, yani

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

Ama gelecekte standartta yeni bir kayan nokta türü olmayacağını gerçekten biliyor musunuz? long double ? Yapmazsın.

İşte bu yüzden ilk çözüm çok güzel. Standardın yeni bir tip için trigonometrik fonksiyonları aşırı yükleyeceğinden emin olabilirsiniz.

Ve lütfen, başlangıçta trigonometrik bir fonksiyonun değerlendirilmesinin performans cezası olduğunu söyleme.

Tüm üsleri kapsayan projedeki ortak başlığımdan birinde aşağıdakileri kullanıyorum:

#define _USE_MATH_DEFINES
#include <cmath>

#ifndef M_PI
#define M_PI (3.14159265358979323846)
#endif

#ifndef M_PIl
#define M_PIl (3.14159265358979323846264338327950288)
#endif

Yan notta, aşağıdaki derleyicilerin tümü eklerseniz M_PI ve M_PIl sabitlerini tanımlar <cmath>. Yalnızca VC ++ için gerekli olan #define _USE_MATH_DEFINES eklemenize gerek yoktur.

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

Genelde kendimi tanımlamayı tercih ederim: const double PI = 2*acos(0.0); çünkü tüm uygulamalar sizin için bunu sağlamaz.

Bu işlevin çalışma zamanında çağrılıp çağrılmadığı veya derleme zamanında statik olup olmadığı sorusu genellikle sorun değildir, çünkü yine de yalnızca bir kez olur.

Bu makaleye C ++ 14 ve üstü için harika bir ipucu olan Danny Kalev tarafından rastladım .

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

Özellikle şablonlar türe göre kullanabildiğinden, bunun oldukça havalı olduğunu düşündüm (orada yapabileceğim en yüksek hassasiyetli PI'yi kullanacağım).

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>

M_PI, M_PI_2, M_PI_4 vb. Değerler standart C ++ değildir, bu nedenle bir constexpr daha iyi bir çözüm gibi görünür. Aynı pi'yi hesaplayan farklı const ifadeleri formüle edilebilir ve bana (hepsi) bana tam doğruluğu sağlayıp sağlamadıklarını ilgilendirir. C ++ standardı pi'nin nasıl hesaplanacağından açıkça bahsetmez. Bu nedenle, pi'yi manuel olarak tanımlamaya geri dönme eğilimindeyim. Aşağıda tüm pi kesirlerini tam doğrulukla destekleyen çözümü paylaşmak istiyorum.

#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;
}

Pencerelerin (cygwin + g ++) üzerinde, bunun gerekli bayrağı eklemek buldum -D_XOPEN_SOURCE=500tanımını işlemek önişlemcisinden için M_PIde math.h.

C ++ 14 yapmanıza izin verir static constexpr auto pi = acos(-1);

Bazı zarif çözümler. Trigonometrik fonksiyonların hassasiyetinin, tiplerin hassasiyetine eşit olduğundan şüpheliyim. Sabit bir değer yazmayı tercih edenler için, bu g ++ için çalışır: -

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

Gelecekteki uzun uzun uzun çift tip için 256 ondalık basamak doğruluğu yeterli olmalıdır. Daha fazlası gerekirse https://www.piday.org/million/ adresini ziyaret edin .

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

Bunu yapabilirsiniz:

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

Eğer M_PIzaten tanımlanmış cmath, bu dahil daha başka bir şey yapmayacağım cmath. Eğer M_PI(Visual Studio, örneğin durumda) tanımlanmamıştır, onu tanımlayacaktır. Her iki durumda da,M_PI pi değerini almak için .

Bu pi değeri Qt Creator'ın qmath.h dosyasından gelir.

Bunu kullanabilirsiniz:

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

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

Matematik Sabitler Standart C / C ++ 'da tanımlanmamıştır. Bunları kullanmak için, önce veya öğelerini tanımlamanız _USE_MATH_DEFINESve sonra eklemeniz gerekir .cmathmath.h