C ++ में PI स्थिरांक का उपयोग कैसे करें

Question

मैं कुछ C ++ प्रोग्राम में PI निरंतर और त्रिकोणमितीय कार्यों का उपयोग करना चाहता हूं। मुझे त्रिकोणमितीय फ़ंक्शंस मिलते हैं include <math.h>। हालाँकि, इस हेडर फ़ाइल में PI के लिए कोई परिभाषा नहीं है।

मैं मैन्युअल रूप से परिभाषित किए बिना पीआई कैसे प्राप्त कर सकता हूं?

Comments

@tiwo, क्या आप पूछ रहे हैं कि क्या अंतर है 3.14, 3.141592और atan(1) * 4?

— निकोला मालेश्वेवी

एक तरफ ध्यान दें, cmath ++ math.h के बजाय सी में इस्तेमाल किया जाना चाहिए, जिसके लिए सी है

— juzzlin

धीरे-धीरे संबंधित: परिभाषा से सीधे पीआई के मूल्य की गणना करने के तरीके पर cise.ufl.edu/~manuel/obfuscate/pi.c देखें ।

— लोरो

यह C ++ 20 में आ गया है! stackoverflow.com/a/57285400/895245

— Ciro Santilli .com/ 冠状 / / 六四 六四

Answer 1

कुछ (विशेष रूप से पुराने) प्लेटफार्मों (नीचे टिप्पणी देखें) पर आपको आवश्यकता हो सकती है

#define _USE_MATH_DEFINES

और फिर आवश्यक हेडर फ़ाइल शामिल करें:

#include <math.h>

और पाई के मूल्य के माध्यम से पहुँचा जा सकता है:

M_PI

मेरे में math.h (2014) में इसे इस प्रकार परिभाषित किया गया है:

# define M_PI           3.14159265358979323846  /* pi */

लेकिन अपने math.hऔर अधिक के लिए जाँच करें । "पुराने" से एक अर्कmath.h (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.
 */

तथापि:

1. नए प्लेटफार्मों पर (कम से कम मेरे 64 बिट Ubuntu 14.04 पर) मुझे परिभाषित करने की आवश्यकता नहीं है _USE_MATH_DEFINES

2. (हाल ही में) लिनक्स प्लेटफॉर्म पर long doubleएक मान है जिसे GNU एक्सटेंशन के रूप में प्रदान किया गया है:

   # define M_PIl          3.141592653589793238462643383279502884L /* pi */

Comments

#define _USE_MATH_DEFINESजिसके बाद #include <math.h>परिभाषित करता है M_PIदृश्य C ++। धन्यवाद।

— Etan

साइबरविन हेडर के साथ भी काम करता है।

— रोब

आप हमेशा के cmathबजाय शामिल कर सकते हैं math.h।

— रिचर्ड जे। रॉस III

परिभाषित करने के बाद भी _USE_MATH_DEFINESअगर जीसीसी शिकायत करता है कि क्योंकि __STRICT_ANSI__परिभाषित किया गया है (शायद आप पास हो गए हैं ) -pedanticया -std=c++11जिसे M_PIपरिभाषित किया जाना है, इसलिए इसे अपरिभाषित करें -D__STRICT_ANSI__। इसे स्वयं को परिभाषित करते समय, चूंकि यह C ++ है, इसके बजाय आपको एक मैक्रो चाहिए constexpr auto M_PI = 3.14159265358979323846;।

— किंवदंतियां 2

2018 तक, उत्तर को निश्चित रूप से <mathath.h> के बजाय <cmath> का उपयोग करने के लिए अपडेट किया जाना चाहिए

— jaskmar

Answer 2

पाई की गणना इस प्रकार की जा सकती है atan(1)*4। आप इस तरह से मूल्य की गणना कर सकते हैं और इसे कैश कर सकते हैं।

Comments

C ++ 11 उपयोगकर्ताओं के लिए:constexpr double pi() { return std::atan(1)*4; }

— matiu

-1: केवल तभी काम करता है जब atan(1)*4 == 3.141592653589793238462643383279502884(मोटे तौर पर बोल रहा हो)। मैं इस पर दांव नहीं लगाऊंगा। सामान्य रहें और स्थिर को परिभाषित करने के लिए एक कच्चे शाब्दिक का उपयोग करें। जब आपको आवश्यकता नहीं है तो सटीक क्यों खोना है?

— थॉमस एडिंग

एक के साथ गुणा ऑपरेशन से बच सकते हैं atan2(0, -1);।

— किंवदंतियों 2

@ मतिउ atanनहीं है constexpr।

— आर। मार्टिनो फर्नांडिस

प्रयास करें acos(-1)बजाय, के लिए कोई ज़रूरत नहीं atan2।

— user541686

Answer 3

आप बूस्ट का उपयोग भी कर सकते हैं, जो कि अनुरोधित प्रकार (यानी फ्लोट बनाम डबल) के लिए अधिकतम सटीकता के साथ महत्वपूर्ण गणित स्थिरांक को परिभाषित करता है।

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

की जाँच करें बढ़ावा प्रलेखन और उदाहरण के लिए।

Comments

बूस्ट: 1999 के बाद से सी ++ की पहले से ही अनावश्यक जटिलता को बढ़ावा देना!

— दान मोल्डिंग

आकर्षक और आंशिक रूप से सच है। दूसरी ओर बढ़ावा कई बार अभूतपूर्व रूप से उपयोगी हो सकता है ...

— BuschnicK

@DanMoulding: उम्म। क्या सी केवल दूसरी भाषा है जिसे आप जानते हैं? क्योंकि मैं जानता हूँ कि सी को छोड़कर अन्य सभी भाषाओं में एक मानक पुस्तकालय है जो C ++ '(जैसे पायथन, हास्केल, सी #, पीएचपी, डेल्फी, एर्लांग, जावा, ......) की तुलना में बड़ा है। व्यक्तिगत अनुभव से, कि अभिजात-वर्ग not gonna use libsएक कीट है और शायद C ++ में लिखे गए खराब सॉफ़्टवेयर का एक कारण है।

— सेबेस्टियन मच

@ ग्रेचस: यूप। पुस्तकालयों के बिना (या नए C ++ 11 पुस्तकालयों के बिना) सी ++ है, जितना मुझे वह भाषा पसंद है और जितना मैं खुद को सब कुछ कोड करना चाहता हूं, उतना उत्पादक नहीं है।

— सेबेस्टियन मच

मेरा मानना ​​है कि उन्होंने कहा कि जटिलता आकार नहीं है । संभवत: a) 3 नेस्टेड नेमस्पेस, और b) pi को केवल एक सामान्य स्थिरांक के बजाय टेम्पर्ड फ़ंक्शन के रूप में परिभाषित करता है।

— टिमम्म

Answer 4

इसके बजाय चिप पर FPU इकाई से प्राप्त करें:

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

double PI = get_PI();

Comments

:-) शायद वह मंच स्वतंत्र नहीं था, लेकिन एक अच्छा अतिरिक्त विदेशी समाधान!

— इतन

मैं तुमसे प्यार करता हूँ, हालांकि तुम यहाँ बॉक्स से बाहर;)

— VivienLeger

मुझे यह जवाब पसंद है। पुराने x86 प्लेटफ़ॉर्म को लक्षित करते समय यह विशेष रूप से उपयोगी है जो कि देर से आने वाली एक छोटी सी सनक है जहाँ अनुकूलन करने वाले कंपाइलर आधुनिक रूप से बहुत अधिक शामिल नहीं हैं। इस हेनरिक के लिए धन्यवाद!

— मैट

Answer 5

मैं आपको सटीक रूप से पीआई में टाइप करने की सलाह दूंगा। यह आपके निष्पादन के लिए कोई गणना समय नहीं जोड़ेगा, और यह किसी भी हेडर या #defines का उपयोग किए बिना पोर्टेबल होगा। एकांत मूल्य का उपयोग करने की तुलना में एको या एटान की गणना करना हमेशा अधिक महंगा होता है।

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

Comments

यह एक महान उदाहरण है कि हमें यह दृष्टिकोण क्यों नहीं अपनाना चाहिए, हम लोग गलती करते हैं, गोलाई, नकल और चिपकाने आदि, मुझे लगता है कि M_PI का उपयोग करना सही दृष्टिकोण है।

— nacho4d

यदि C ++ 11 में कोई ऐसा कर रहा है, तो consta constexpr।

— लीजेंड्स 2

@ nacho4d मैं भी M_PI पसंद करता हूं अगर यह उपलब्ध है, लेकिन सभी सिस्टम POSIX के अनुरूप नहीं हैं। मुझे लगता है कि यह दृष्टिकोण उन मामलों के लिए 4 * atan (1) विधि से बेहतर है जहां M_PI उपलब्ध नहीं है।

— m24p

"एको या एटन की गणना करना हमेशा अधिक महंगा होता है" यह सच नहीं है। कोई भी आधुनिक अनुकूलन कंपाइलर मानक गणित कार्यों के बारे में सब जानता है और उनके माध्यम से निरंतर प्रचार कर सकता है। उदाहरण देखें goo.gl/BvdJyr

— निमो

@ नीमो, काउंटर उदाहरण: Godbolt.org/g/DsAern जैसा कि कहीं और कहा गया है, ऐसा प्रतीत होता है कि वर्तमान में केवल GCC ही ऐसा करता है और इसकी संभावना है क्योंकि इसने मूल गणित कार्यों की घोषणा की है constexpr।

— पार्कर कोट

Answer 6

लिखने के बजाय

#define _USE_MATH_DEFINES

मैं आपके संकलक के आधार पर उपयोग करने -D_USE_MATH_DEFINESया करने की सलाह /D_USE_MATH_DEFINESदूंगा।

इस तरह से आपको आश्वस्त किया जाता है कि आपके द्वारा (और #define के बिना) शीर्षलेख सहित किसी की स्थिति में भी, आपके पास अब भी अस्पष्ट संकलक त्रुटि के बजाय स्थिरांक होंगे जिन्हें आप नीचे ट्रैक करने में उम्र लेंगे।

Comments

अच्छा सुझाव। यदि "आप" एक संकलन इकाई है तो निश्चित रूप से आप यह सुनिश्चित कर सकते हैं कि कुछ भी शामिल करने से पहले मैक्रो को परिभाषित किया गया है। लेकिन अगर "आप" एक हेडर फ़ाइल है, तो यह आपके नियंत्रण से बाहर है।

— स्टीव जेसप

वास्तव में भले ही "आप" एक संकलन इकाई हो ... हेडर के आदेश के आधार पर रखरखाव दुःस्वप्न की ओर सबसे छोटा रास्ता है ...

— Matthieu M.

हालाँकि आपको शीर्षलेखों के क्रम पर निर्भर नहीं होना पड़ेगा। इससे कोई फर्क नहीं पड़ता कि हेडर एक-दूसरे को शामिल करते हैं, बशर्ते कि आप कुछ भी करने से पहले #define करें (कम से कम, यह मानते हुए कि # कुछ भी नहीं है)। वही NDEBUG पर लागू होता है।

— स्टीव जेसोप

एक परियोजना में बहुत ही सामान्य मुद्दा यह है कि यदि आप विजुअल स्टूडियो के साथ संकलन कर रहे हैं, उदाहरण के लिए आप यह नहीं जानते हैं कि कंपाइलर आपकी फ़ाइलों के माध्यम से किस क्रम में जा रहा है तो यदि आप <cmath>विभिन्न स्थानों पर उपयोग करते हैं तो यह एक बड़ा दर्द बन जाता है (विशेष रूप से) यदि यह आपके द्वारा शामिल किए गए अन्य पुस्तकालय द्वारा शामिल है)। यह बेहतर होता अगर वे उस हिस्से को हेडर गार्ड्स के बाहर रख देते लेकिन अब इस बारे में ज्यादा कुछ नहीं कर सकते। संकलक निर्देश वास्तव में बहुत अच्छी तरह से काम करता है।

— मेन्डेलल

Answer 7

चूंकि आधिकारिक मानक पुस्तकालय एक निरंतर पीआई को परिभाषित नहीं करता है इसलिए आपको इसे स्वयं परिभाषित करना होगा। तो आपके प्रश्न का उत्तर "मैं मैन्युअल रूप से परिभाषित किए बिना पीआई कैसे प्राप्त कर सकता हूं?" "आप नहीं हैं - या आप कुछ संकलक-विशिष्ट एक्सटेंशन पर निर्भर हैं।" यदि आप पोर्टेबिलिटी के बारे में चिंतित नहीं हैं तो आप इसके लिए अपने कंपाइलर के मैनुअल की जांच कर सकते हैं।

C ++ आपको लिखने की अनुमति देता है

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

लेकिन इस स्थिरांक का आरंभ स्थिर होने की गारंटी नहीं है। जी ++ संकलक हालांकि उन गणित कार्यों को आंतरिक रूप से संभालता है और संकलन-समय पर इस निरंतर अभिव्यक्ति की गणना करने में सक्षम है।

Comments

मैं आमतौर पर एकोस (-1) का उपयोग करता हूं, जैसा कि आप कहते हैं, वे संकलन-समय का मूल्यांकन करते हैं। जब मैंने M_PI, acos (-1) और atan (1) * 4 का परीक्षण किया, तो मुझे समान मूल्य मिले।

— मीका

पारंपरिक तरीका उपयोग करना है 4*atan(1.): atanइसे लागू करना आसान है और 4 से गुणा करना एक सटीक ऑपरेशन है। बेशक, आधुनिक कंपाइलर आवश्यक गति के साथ सभी स्थिरांक को मोड़ते हैं (मोड़ते हैं), और यह उपयोग करने के लिए पूरी तरह से उचित है acos(-1)या यहां तक ​​कि std::abs(std::arg(std::complex<double>(-1.,0.)))जो यूलर के फार्मूले का उलटा है और इस तरह से अधिक सौंदर्यवादी मनभावन लगता है (मैंने जोड़ा है absक्योंकि मैं डॉन हूं ' टी याद रखें कि जटिल विमान कैसे काटा जाता है या यदि वह बिल्कुल परिभाषित है)।

— tobi_s

बस इसलिए कोई भी गलती से आपको गंभीर नहीं लगता (फिर से -_- ')। यह एक भयानक समाधान है। अतन कार्यान्वयन को मानक के अर्थ से परिभाषित नहीं किया गया है जिसका कार्यान्वयन और संभवतः hw निर्भर है। इसका मतलब यह है कि संख्या विज्ञान भयानक हो सकता है, जिसका अर्थ है कि आप सामान्य रूप से 3.14 का उपयोग करके बेहतर हो सकते हैं। इसके अलावा, संभवतः विशेष मामलों के लिए भी यह काफी धीमा है।

— मध्याजी

Answer 8

से math.h की Posix आदमी पेज :

   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

Comments

अच्छा जवाब लेकिन लिंक मर चुका है। मैं इसके बजाय यह सुझाव देता हूं ।

— अबदराहिम किताउनी

Answer 9

सी ++ 20 std::numbers::pi

आखिरकार, यह आ गया है: http://eel.is/c++draft/numbers

मुझे उम्मीद है कि उपयोग की तरह होगा:

#include <numbers>
#include <iostream>

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

जब समर्थन जीसीसी के लिए आता है, तो मैं इसे एक कोशिश देता हूं, जीसीसी 9.1.0 के साथ g++-9 -std=c++2aअभी भी इसका समर्थन नहीं करता है।

स्वीकृत प्रस्ताव का वर्णन है:

5.0। "हेडर्स" [हेडर] तालिका में [टैब: cpp.library.headers], एक नए <math>हेडर को जोड़ना होगा।

[...]

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

वहाँ भी एक std::numbers::eकोर्स है :-) कैसे C ++ में संचालित यूलर निरंतर या यूलर की गणना करने के लिए?

ये स्थिरांक C ++ 14 चर टेम्पलेट सुविधा का उपयोग करते हैं: C ++ 14 चर टेम्पलेट: उनका उद्देश्य क्या है? कोई उपयोग उदाहरण?

मसौदे के पिछले संस्करणों में, निरंतर था std::math::pi: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0631r7.pdf

Answer 10

मानक C ++ में PI के लिए स्थिरांक नहीं है।

कई सी ++ संकलक एक गैर-मानक विस्तार के रूप M_PIमें cmath(या math.hसी के लिए) को परिभाषित करते हैं । #define _USE_MATH_DEFINESइसे देखने से पहले आपको यह करना पड़ सकता है ।

Answer 11

मुझे क्या करना होगा

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

या

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

मैं आपकी जरूरत के हिसाब से टाइपिंग नहीं करूंगा । इसका क्या मतलब है? आपको जिस सटीकता की आवश्यकता है, वह सटीक है , लेकिन हम इसके बारे में कुछ नहीं जानते हैंTT ।

आप कह सकते हैं: आप किस बारे में बात कर रहे हैं? Tहोगा float, doubleया long double। तो, बस की शुद्धता में टाइप करें long double, यानी

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

लेकिन क्या आप वास्तव में जानते हैं कि भविष्य में मानक से अधिक सटीक सटीकता के साथ एक नया फ्लोटिंग पॉइंट प्रकार नहीं होगा long double? तुम नहीं।

और इसीलिए पहला उपाय सुंदर है। आप यह सुनिश्चित कर सकते हैं कि मानक एक नए प्रकार के लिए त्रिकोणमितीय कार्यों को अधिभारित करेगा।

और कृपया, यह मत कहो कि प्रारंभ में त्रिकोणमितीय फ़ंक्शन का मूल्यांकन एक प्रदर्शन दंड है।

Comments

arg(log(x)) == πसभी के लिए ध्यान दें 0 < x < 1।

— 0xbadf00d

यह एक भयानक विचार है। एक प्रकार के अतिभारित टेम्पलेट कॉन्स्ट्रेप का उपयोग करें, इस तरह से आपको एक नई त्रुटि दिखाई देने पर उसे परिभाषित करने के लिए मजबूर करने के लिए एक संकलन त्रुटि मिलती है। इसका भी आम तौर पर एक भयानक है क्योंकि ट्रिगर प्रकार केवल अस्थायी बिंदु प्रकार तक सीमित नहीं हैं। इसलिए एटैन (1) गलती का आनंद लें ... मानक इस बात की गारंटी नहीं देता है कि त्रिकोणमितीय फ़ंक्शन प्रकार की सटीकता के लिए उनके वास्तविक त्रिकोणमितीय मानों की गणना करते हैं। वे आम तौर पर नहीं करते हैं, और यह उदाहरण के लिए तेजी से खराब हो जाता है और विशेष मूल्यों के लिए हमेशा खराब होता है।

— मध्यरात्रि

Answer 12

मैं अपने सभी शीर्षकों को शामिल करने वाले प्रोजेक्ट में अपने सामान्य हेडर में निम्नलिखित का उपयोग करता हूं:

#define _USE_MATH_DEFINES
#include <cmath>

#ifndef M_PI
#define M_PI (3.14159265358979323846)
#endif

#ifndef M_PIl
#define M_PIl (3.14159265358979323846264338327950288)
#endif

एक साइड नोट पर, नीचे के सभी कंपाइलर M_PI और M_PIl स्थिरांक को परिभाषित करते हैं यदि आप शामिल करते हैं <cmath>। केवल USE #define _USE_MATH_DEFINES जोड़ने की आवश्यकता नहीं है जो केवल VC ++ के लिए आवश्यक है।

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

Comments

क्या डाउनवॉटर इस जवाब में गलत है, इस पर टिप्पणी कर सकता है। यह अच्छी तरह से शोध और परीक्षण और वास्तविक प्रणाली में उपयोग में है। मुझे निश्चित रूप से इसमें सुधार करना पसंद था अगर कुछ गलत है।

— शीतल शाह

FYI करें, बोरलैंड C ++ कंपाइलर भी M_PIज़रूरत के बिना परिभाषित करते हैं_USE_MATH_DEFINES

— रेमी लेबेऊ

Answer 13

मैं आम तौर पर अपने स्वयं को परिभाषित करना पसंद करता हूं: const double PI = 2*acos(0.0);क्योंकि सभी कार्यान्वयन आपके लिए इसे प्रदान नहीं करते हैं।

यह सवाल कि क्या इस फ़ंक्शन को रनटाइम पर कॉल किया जाता है या संकलित समय पर स्थिर किया जाता है, आमतौर पर एक मुद्दा नहीं होता है, क्योंकि यह केवल एक बार फिर भी होता है।

Comments

acos (-1) भी पाई है।

— रॉड्रिक टेलर

स्मृति स्थान से एक ऑपरेंड पढ़ने की तुलना में तत्काल ऑपरेंड लोड करने के लिए अक्सर सीपीयू निर्देश और / या कम विलंबता कम होती है। इसके अलावा, केवल अभिव्यक्तियाँ जो संकलन-समय पर जानी जाती हैं, उन्हें पूर्व-संगणित किया जा सकता है (मेरा मतलब है double x = pi * 1.5;और पसंद है)। यदि आप कभी तंग छोरों में कुरकुरे गणित में पीआई का उपयोग करने का इरादा रखते हैं, तो आप बेहतर सुनिश्चित करते हैं कि मूल्य संकलक को पता है।

— यूजीन रियात्सेव

Answer 14

मैं बस में आए इस लेख से डैनी Kalev जो सी ++ 14 और ऊपर के लिए एक महान टिप है।

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

मैंने सोचा कि यह बहुत अच्छा था (हालांकि मैं वहां उच्चतम परिशुद्धता पीआई का उपयोग कर सकता हूं), खासकर क्योंकि टेम्पलेट प्रकार के आधार पर इसका उपयोग कर सकते हैं।

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>

Answer 15

मान जैसे M_PI, M_PI_2, M_PI_4, आदि मानक C ++ नहीं हैं, इसलिए एक constexpr एक बेहतर समाधान लगता है। विभिन्न कास्ट एक्सप्रेशन तैयार किए जा सकते हैं जो एक ही पाई की गणना करते हैं और यह मुझे चिंतित करता है कि क्या वे (सभी) मुझे पूरी सटीकता प्रदान करते हैं। C ++ मानक स्पष्ट रूप से उल्लेख नहीं करता है कि पाई की गणना कैसे करें। इसलिए, मैं मैन्युअल रूप से पाई को परिभाषित करने के लिए वापस गिर जाता हूं। मैं नीचे दिए गए समाधान को साझा करना चाहूंगा, जो पूरी सटीकता के साथ पाई के सभी प्रकार के अंशों का समर्थन करता है।

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

Comments

बहुत अच्छा। उस संख्या के अंत में "l" या "L" होना आवश्यक हो सकता है। मुझे अपने कंपाइलर gcc से linux पर एक संकीर्ण चेतावनी मिलती है।

— ग्रांट रोस्टिग

Answer 16

विंडोज़ पर (cygwin + g ++), मैंने -D_XOPEN_SOURCE=500इसकी परिभाषा को संसाधित करने के लिए प्रीप्रोसेसर के लिए ध्वज जोड़ना आवश्यक पाया M_PIहै math.h।

Comments

यह एक जवाब नहीं है, लेकिन फ्रिट्ज़ोन के जवाब के लिए एक टिप्पणी है।

— 0xbadf00d

@ 0xbadf00d: यह एक पूरी तरह से स्टैंडअलोन उत्तर है जो M_PIकिसी विशेष प्लेटफॉर्म पर काम करने के लिए आवश्यक कदम प्रदान करता है। यह किसी भी अन्य मंच के लिए एक जवाब पर कोई टिप्पणी नहीं है कि किसी अन्य मंच के लिए एक उत्तर इस पर एक टिप्पणी है।

— बेन वोइगट

Answer 17

C ++ 14 आपको देता है static constexpr auto pi = acos(-1);

Comments

std::acosएक नहीं है constexpr। तो, आपका कोड संकलन नहीं करेगा।

— 0xbadf00d

@ 0xbadf00d मैंने इसे g ++

— Willy Goat

@WillyGoat: फिर जी ++ गलत है, क्योंकि acosनहीं है constexprसी ++ 14 में, और बनने के लिए प्रस्तावित नहीं है constexpr++ 17 सी में भी

— बेन वोइट

@BenVoigt क्या कोई गणित कार्य हैं constexpr? जाहिरा तौर पर नहीं: stackoverflow.com/questions/17347935/constexpr-math-functions

— wcochran

@wcochran: ऐसे बहुत से नए गणित कार्य हैं जो constexprउदाहरण के लिए देखें ( github.com/kthohr/gcex )। लेकिन वे एक ही नाम के सी कार्यों के साथ पिछड़े-संगत नहीं हैं, इसलिए वे पुराने नामों को नहीं ले सकते हैं।

— बेन वायगट

Answer 18

कुछ सुरुचिपूर्ण समाधान। मुझे संदेह है कि त्रिकोणमितीय फ़ंक्शंस की परिशुद्धता, हालांकि प्रकारों की सटीकता के बराबर है। उन लोगों के लिए जो एक निरंतर मूल्य लिखना पसंद करते हैं, यह g ++ के लिए काम करता है: -

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

किसी भी भविष्य के लंबे लंबे डबल प्रकार के लिए 256 दशमलव अंक सटीकता पर्याप्त होनी चाहिए। यदि अधिक आवश्यक हैं तो https://www.piday.org/million/ पर जाएं ।

Answer 19

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

Answer 20

तुम यह केर सकते हो:

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

यदि M_PIपहले से ही इसमें परिभाषित किया गया है cmath, तो इसमें कुछ और शामिल नहीं होगा cmath। यदि M_PIइसे परिभाषित नहीं किया गया है (जो विजुअल स्टूडियो में उदाहरण के लिए मामला है), तो यह इसे परिभाषित करेगा। दोनों ही मामलों में, आप M_PIपाई का मान प्राप्त करने के लिए उपयोग कर सकते हैं ।

Pi का यह मूल्य Qt Creator के qmath.h से आता है।

Answer 21

आप इसका उपयोग कर सकते हैं:

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

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

गणित कांस्टेंट को मानक C / C ++ में परिभाषित नहीं किया गया है। उनका उपयोग करने के लिए, आपको पहले परिभाषित करना होगा _USE_MATH_DEFINESऔर फिर शामिल करना होगा cmathया math.h।