Cara menggunakan konstanta PI di C ++

Saya ingin menggunakan fungsi konstanta PI dan trigonometri dalam beberapa program C ++. Saya mendapatkan fungsi trigonometri dengan include <math.h>. Namun, sepertinya tidak ada definisi untuk PI dalam file header ini.

Bagaimana saya bisa mendapatkan PI tanpa mendefinisikannya secara manual?

Pada beberapa platform (terutama yang lebih tua) (lihat komentar di bawah), Anda mungkin perlu melakukannya

#define _USE_MATH_DEFINES

dan kemudian sertakan file header yang diperlukan:

#include <math.h>

dan nilai pi dapat diakses melalui:

M_PI

Dalam math.h(2014) saya ini didefinisikan sebagai:

# define M_PI           3.14159265358979323846  /* pi */

tetapi periksa math.hlebih lanjut. Ekstrak dari "lama" math.h(tahun 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.
 */

Namun:

1. pada platform yang lebih baru (setidaknya pada 64 bit Ubuntu 14.04 saya) saya tidak perlu mendefinisikan _USE_MATH_DEFINES

2. Pada platform Linux (baru-baru ini) ada long doublenilai - nilai yang juga disediakan sebagai Ekstensi GNU:

   # define M_PIl          3.141592653589793238462643383279502884L /* pi */

Pi dapat dihitung sebagai atan(1)*4. Anda bisa menghitung nilainya dengan cara ini dan menyimpannya.

Anda juga bisa menggunakan boost, yang mendefinisikan konstanta matematika penting dengan akurasi maksimum untuk tipe yang diminta (yaitu float vs double).

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

Lihat dokumentasi peningkatan untuk lebih banyak contoh.

Alih-alih mendapatkannya dari unit FPU pada chip:

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

double PI = get_PI();

Saya akan merekomendasikan hanya mengetik pi ke presisi yang Anda butuhkan. Ini tidak akan menambah waktu kalkulasi untuk eksekusi Anda, dan ini akan portabel tanpa menggunakan header atau #define. Menghitung Acos atau Atan selalu lebih mahal daripada menggunakan nilai yang telah dihitung.

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

Daripada menulis

#define _USE_MATH_DEFINES

Saya akan merekomendasikan menggunakan -D_USE_MATH_DEFINESatau /D_USE_MATH_DEFINESbergantung pada kompiler Anda.

Dengan cara ini Anda yakin bahwa bahkan dalam hal seseorang termasuk tajuk sebelum Anda melakukannya (dan tanpa #define) Anda masih akan memiliki konstanta alih-alih kesalahan kompiler yang tidak jelas yang perlu waktu lama untuk dilacak.

Karena pustaka standar resmi tidak mendefinisikan PI konstan, Anda harus mendefinisikannya sendiri. Jadi jawaban untuk pertanyaan Anda "Bagaimana saya bisa mendapatkan PI tanpa mendefinisikannya secara manual?" adalah "Anda tidak - atau Anda mengandalkan beberapa ekstensi khusus-kompiler.". Jika Anda tidak khawatir tentang portabilitas Anda dapat memeriksa manual kompiler Anda untuk ini.

C ++ memungkinkan Anda untuk menulis

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

tetapi inisialisasi konstanta ini tidak dijamin statis. Namun kompiler G ++ menangani fungsi matematika tersebut sebagai intrinsik dan mampu menghitung ekspresi konstan ini pada waktu kompilasi.

Dari halaman manual Posix di 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

Akhirnya, sudah tiba: http://eel.is/c++draft/numbers

Saya berharap penggunaannya menjadi seperti:

#include <numbers>
#include <iostream>

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

Saya akan mencobanya ketika dukungan datang ke GCC, GCC 9.1.0 dengan g++-9 -std=c++2amasih tidak mendukungnya.

Proposal yang diterima menjelaskan:

5.0. "Header" [header] Di tabel [tab: cpp.library.headers], <math>header baru perlu ditambahkan.

[...]

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

Ada juga std::numbers::etentu saja :-) Bagaimana cara menghitung konstanta Euler atau bertenaga Euler di C ++?

Konstanta ini menggunakan fitur templat variabel C ++ 14 : C ++ 14 Templat Variabel: apa tujuannya? Adakah contoh penggunaan?

Dalam versi draft sebelumnya, konstanta berada di bawah std::math::pi: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0631r7.pdf

Standar C ++ tidak memiliki konstanta untuk PI.

Banyak C ++ compiler menentukan M_PIdi cmath(atau di math.hC) sebagai ekstensi non-standar. Anda mungkin harus #define _USE_MATH_DEFINESsebelum dapat melihatnya.

Saya akan lakukan

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

atau

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

Saya tidak akan mengetikkan π dengan presisi yang Anda butuhkan . Apa artinya itu? The presisi yang Anda butuhkan adalah ketepatan T, tapi kita tahu apa-apa tentangT .

Anda mungkin berkata: Apa yang sedang Anda bicarakan? Takan float, doubleatau long double. Jadi, ketikkan saja ketepatannya long double, yaitu

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

Tapi apakah Anda benar-benar tahu bahwa tidak akan ada tipe floating point baru dalam standar di masa depan dengan presisi yang lebih tinggi daripada long double ? Kamu tidak.

Dan itulah mengapa solusi pertama itu indah. Anda dapat yakin bahwa standar akan membebani fungsi trigonometri untuk tipe baru.

Dan tolong, jangan katakan bahwa evaluasi fungsi trigonometri pada inisialisasi adalah penalti kinerja.

Saya menggunakan berikut ini di salah satu header umum saya di proyek yang mencakup semua pangkalan:

#define _USE_MATH_DEFINES
#include <cmath>

#ifndef M_PI
#define M_PI (3.14159265358979323846)
#endif

#ifndef M_PIl
#define M_PIl (3.14159265358979323846264338327950288)
#endif

Di samping catatan, semua kompiler di bawah ini mendefinisikan konstanta M_PI dan M_PIl jika Anda menyertakan <cmath>. Tidak perlu menambahkan `#define _USE_MATH_DEFINES yang hanya diperlukan untuk VC ++.

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

Saya biasanya lebih suka mendefinisikan sendiri: const double PI = 2*acos(0.0); karena tidak semua implementasi menyediakannya untuk Anda.

Pertanyaan apakah fungsi ini dipanggil pada saat runtime atau statis pada saat kompilasi biasanya tidak menjadi masalah, karena itu hanya terjadi sekali saja.

Saya baru saja menemukan artikel ini oleh Danny Kalev yang memiliki tip bagus untuk C ++ 14 ke atas.

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

Saya pikir ini cukup keren (walaupun saya akan menggunakan PI presisi tertinggi di sana saya bisa), terutama karena template dapat menggunakannya berdasarkan jenis.

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>

Nilai-nilai seperti M_PI, M_PI_2, M_PI_4, dll bukan standar C ++ sehingga constexpr tampaknya merupakan solusi yang lebih baik. Ekspresi const yang berbeda dapat dirumuskan yang menghitung pi yang sama dan itu menyangkut saya apakah mereka (semua) memberikan saya akurasi penuh. Standar C ++ tidak secara eksplisit menyebutkan cara menghitung pi. Karena itu, saya cenderung kembali ke mendefinisikan pi secara manual. Saya ingin berbagi solusi di bawah ini yang mendukung semua jenis fraksi pi dalam akurasi penuh.

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

Pada windows (cygwin + g ++), saya merasa perlu menambahkan flag -D_XOPEN_SOURCE=500untuk preprocessor untuk memproses definisi M_PIin math.h.

C ++ 14 memungkinkan Anda melakukannya static constexpr auto pi = acos(-1);

Beberapa solusi elegan. Saya ragu bahwa ketepatan fungsi trigonometri sama dengan ketepatan jenis. Bagi mereka yang lebih suka menulis nilai konstan, ini berfungsi untuk g ++: -

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

Keakuratan 256 desimal digit harus cukup untuk jenis ganda panjang di masa mendatang. Jika diperlukan, kunjungi https://www.piday.org/million/ .

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

Kamu bisa melakukan ini:

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

Jika M_PIsudah didefinisikan dalam cmath, ini tidak akan melakukan apa pun selain memasukkan cmath. Jika M_PItidak didefinisikan (yang merupakan kasus misalnya di Visual Studio), itu akan mendefinisikannya. Dalam kedua kasus, Anda dapat menggunakanM_PI untuk mendapatkan nilai pi.

Nilai pi ini berasal dari qmath.h Qt Creator.

Anda bisa menggunakannya:

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

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

Konstanta Matematika tidak didefinisikan dalam Standar C / C ++. Untuk menggunakannya, Anda harus terlebih dahulu mendefinisikan _USE_MATH_DEFINESdan kemudian memasukkan cmathatau math.h.