NumPy 1.14 - NPY_NAN

NumPy कोर लाइब्रेरीज़




numpy

NumPy कोर लाइब्रेरीज़

संस्करण 1.3.0 में नया।

1.3.0 से शुरू होकर, हम अजगर आश्रित कोड से शुद्ध C, "कम्प्यूटेशनल" कोड को अलग करने पर काम कर रहे हैं। लक्ष्य दोहरा है: कोड को क्लीनर बनाना, और कोड को अन्य एक्सटेंशनों द्वारा सुन्न (स्कैपी, आदि) के बाहर पुन: उपयोग को सक्षम करना।

NumPy कोर गणित पुस्तकालय

संख्यात्मक कोर गणित पुस्तकालय ('npymath') इस दिशा में एक पहला कदम है। इस लाइब्रेरी में सबसे अधिक गणित से संबंधित C99 कार्यक्षमता है, जिसका उपयोग उन प्लेटफार्मों पर किया जा सकता है जहां C99 अच्छी तरह से समर्थित नहीं है। कोर गणित के कार्यों में C99 वालों के समान ही API है, सिवाय npy_ * उपसर्ग के।

उपलब्ध फ़ंक्शन <numpy / npy_math.h> में परिभाषित किए गए हैं - कृपया इस हेडर को संदेह होने पर देखें।

फ़्लोटिंग पॉइंट वर्गीकरण

NPY_NAN

इस मैक्रो को एक NaN (संख्या नहीं) के रूप में परिभाषित किया गया है, और साइन इनसेट ('सकारात्मक' NaN) की गारंटी है। इसी एकल और विस्तार सटीक मैक्रो प्रत्यय एफ और एल के साथ उपलब्ध हैं।

NPY_INFINITY

इस मैक्रो को एक सकारात्मक inf के रूप में परिभाषित किया गया है इसी एकल और विस्तार सटीक मैक्रो प्रत्यय एफ और एल के साथ उपलब्ध हैं।

NPY_PZERO

इस मैक्रो को सकारात्मक शून्य में परिभाषित किया गया है। इसी एकल और विस्तार सटीक मैक्रो प्रत्यय एफ और एल के साथ उपलब्ध हैं।

NPY_NZERO

यह मैक्रो नकारात्मक शून्य में परिभाषित किया गया है (जो कि साइन बिट सेट के साथ है)। इसी एकल और विस्तार सटीक मैक्रो प्रत्यय एफ और एल के साथ उपलब्ध हैं।

int npy_isnan(x)

यह एक मैक्रो है, और C99 के समतुल्य के बराबर है: एकल, डबल और विस्तारित परिशुद्धता के लिए काम करता है, और एक गैर 0 मान लौटाता है x एक NaN है।

int npy_isfinite(x)

यह एक मैक्रो है, और C99 के समतुल्य के बराबर है: एकल, डबल और विस्तारित परिशुद्धता के लिए काम करता है, और एक गैर 0 मान लौटाता है x न तो NaN है और न ही अनन्तता है।

int npy_isinf(x)

यह एक मैक्रो है, और C99 isinf के बराबर है: एकल, डबल और विस्तारित परिशुद्धता के लिए काम करता है, और एक गैर 0 मान लौटाता है x अनंत (सकारात्मक और नकारात्मक) है।

int npy_signbit(x)

यह एक मैक्रो है, और C99 साइनबिट के बराबर है: एकल, डबल और विस्तारित परिशुद्धता के लिए काम करता है, और एक गैर 0 मान लौटाता है x में साइनबिट सेट है (यह संख्या नकारात्मक है)।

double npy_copysign(double x, double y)

यह C99 कॉपीसाइन के बराबर एक फ़ंक्शन है: x को y के समान चिह्न के साथ लौटाएं। किसी भी मूल्य के लिए काम करता है, जिसमें inf और nan शामिल हैं। सिंगल और विस्तारित प्रिडिक्शन प्रत्यय f और l के साथ उपलब्ध हैं।

संस्करण 1.4.0 में नया।

उपयोगी गणित निरंतर

निम्नलिखित गणित स्थिरांक npy_math.h में उपलब्ध हैं। एकल और विस्तारित परिशुद्धता क्रमशः F और L प्रत्यय जोड़कर उपलब्ध हैं।

NPY_E

प्राकृतिक लघुगणक का आधार ( ई )

NPY_LOG2E

यूलर के बेस 2 के लिए लघुगणक स्थिरांक ( \ Frac {\ ln (ई)} {\ ln (2)} )

NPY_LOG10E

यूलर के बेस 10 के लिए लघुगणक ( \ Frac {\ ln (ई)} {\ ln (10)} )

NPY_LOGE2

2 का प्राकृतिक लघुगणक ( \ Ln (2) )

NPY_LOGE10

10 का प्राकृतिक लघुगणक ( \ Ln (10) )

NPY_PI

पाई ( \ pi )

NPY_PI_2

पाई 2 से विभाजित ( \ Frac {\ pi} {2} )

NPY_PI_4

पाई 4 से विभाजित ( \ Frac {\ pi} {4} )

NPY_1_PI

पी का पारस्परिक ( \ Frac {1} {\ अनुकरणीय} )

NPY_2_PI

पी के दो बार पारस्परिक ( \ Frac {2} {\ अनुकरणीय} )

NPY_EULER
यूलर स्थिर
\ lim_ {n \ rightarrow \ infty} ({\ sum_ {k = 1} ^ n {\ frac {1} {k}} - \ ln n})

निम्न-स्तरीय फ़्लोटिंग पॉइंट हेरफेर

वे सटीक फ्लोटिंग पॉइंट तुलना के लिए उपयोगी हो सकते हैं।

double npy_nextafter(double x, double y)

यह अगली बार C99 के बराबर एक फ़ंक्शन है: y की दिशा में x से अगले प्रतिनिधित्व योग्य फ़्लोटिंग मान लौटाएं। सिंगल और विस्तारित प्रिडिक्शन प्रत्यय f और l के साथ उपलब्ध हैं।

संस्करण 1.4.0 में नया।

double npy_spacing(double x)

यह फोरट्रान आंतरिक के समतुल्य एक फ़ंक्शन है। X और x से अगले प्रतिनिधित्व योग्य फ़्लोटिंग मान के बीच की दूरी, जैसे रिक्ति (1) == eps। नैन और +/- inf वापसी की दूरी। सिंगल और विस्तारित प्रिडिक्शन प्रत्यय f और l के साथ उपलब्ध हैं।

संस्करण 1.4.0 में नया।

void npy_set_floatstatus_divbyzero()

शून्य फ़्लोटिंग पॉइंट अपवाद द्वारा विभाजन को सेट करें

संस्करण 1.6.0 में नया।

void npy_set_floatstatus_overflow()

ओवरफ़्लो फ़्लोटिंग पॉइंट अपवाद सेट करें

संस्करण 1.6.0 में नया।

void npy_set_floatstatus_underflow()

अंडरफ्लो फ्लोटिंग पॉइंट अपवाद सेट करें

संस्करण 1.6.0 में नया।

void npy_set_floatstatus_invalid()

अमान्य फ़्लोटिंग पॉइंट अपवाद सेट करें

संस्करण 1.6.0 में नया।

int npy_get_floatstatus()

फ्लोटिंग पॉइंट स्टेटस प्राप्त करें। निम्नलिखित झंडों के साथ एक बिटमास्क लौटाता है:

  • NPY_FPE_DIVIDEBYZERO
  • NPY_FPE_OVERFLOW
  • NPY_FPE_UNDERFLOW
  • NPY_FPE_INVALID

संस्करण 1.9.0 में नया।

int npy_clear_floatstatus()

फ्लोटिंग पॉइंट स्टेटस साफ़ करता है। पिछला स्थिति मुखौटा लौटाता है।

संस्करण 1.9.0 में नया।

जटिल कार्य

संस्करण 1.4.0 में नया।

C99 जैसे जटिल कार्य जोड़े गए हैं। यदि आप पोर्टेबल सी एक्सटेंशन को लागू करना चाहते हैं, तो उनका उपयोग किया जा सकता है। चूंकि हम अभी भी C99 जटिल प्रकार के बिना प्लेटफार्मों का समर्थन करते हैं, इसलिए आपको C90- संगत सिंटैक्स तक सीमित रखने की आवश्यकता है, जैसे:

/* a = 1 + 2i \*/
npy_complex a = npy_cpack(1, 2);
npy_complex b;

b = npy_log(a);

एक विस्तार में कोर गणित पुस्तकालय के खिलाफ लिंकिंग

संस्करण 1.4.0 में नया।

अपने स्वयं के एक्सटेंशन में कोर गणित लाइब्रेरी का उपयोग करने के लिए, आपको अपने सेटअप में अपने एक्सटेंशन में npymath संकलन और लिंक विकल्प जोड़ने की आवश्यकता है:

>>> from numpy.distutils.misc_util import get_info
>>> info = get_info('npymath')
>>> config.add_extension('foo', sources=['foo.c'], extra_info=info)

दूसरे शब्दों में, blas_info और co का उपयोग करते समय जानकारी का उपयोग बिल्कुल वैसा ही है।

आधा-सटीक कार्य

संस्करण 2.0.0 में नया।

हेडर फ़ाइल <numpy / halffloat.h> IEEE 754-2008 16-बिट फ्लोटिंग पॉइंट मानों के साथ काम करने के लिए फ़ंक्शन प्रदान करता है। हालांकि यह प्रारूप आम तौर पर संख्यात्मक अभिकलन के लिए उपयोग नहीं किया जाता है, यह उन मूल्यों को संग्रहीत करने के लिए उपयोगी है, जिन्हें फ्लोटिंग पॉइंट की आवश्यकता होती है, लेकिन बहुत अधिक सटीकता की आवश्यकता नहीं होती है। इसे फ्लोटिंग पॉइंट राउंड-ऑफ त्रुटि की प्रकृति को समझने के लिए एक शैक्षिक उपकरण के रूप में भी इस्तेमाल किया जा सकता है।

अन्य प्रकारों के लिए, NumPy में 16 बिट फ़्लोट के लिए एक टाइफेड npy_half शामिल है। अधिकांश अन्य प्रकारों के विपरीत, आप इसे C के सामान्य प्रकार के रूप में उपयोग नहीं कर सकते हैं, क्योंकि यह npy_int16 के लिए एक टाइफाइड है। उदाहरण के लिए, 1.0 0x3c00 से C की तरह दिखता है, और यदि आप विभिन्न हस्ताक्षर किए गए शून्य के बीच समानता की तुलना करते हैं, तो आपको -0.0! = 0.0 (0x8000! = 0x0000) मिलेगा, जो गलत है।

इन कारणों के लिए, NumPy <numpy / halffloat.h> और 'npymath' को जोड़ने के द्वारा सुलभ npy_half मूल्यों के साथ काम करने के लिए एक एपीआई प्रदान करता है। ऐसे कार्यों के लिए, जो सीधे प्रदान नहीं किए जाते हैं, जैसे कि अंकगणितीय संचालन, पसंदीदा तरीका यह है कि फ्लोट या डबल और बैक में फिर से कन्वर्ट करें, जैसा कि निम्नलिखित उदाहरण में है।

npy_half sum(int n, npy_half *array) {
    float ret = 0;
    while(n--) {
        ret += npy_half_to_float(*array++);
    }
    return npy_float_to_half(ret);
}

बाहरी कड़ियाँ:

NPY_HALF_ZERO

इस मैक्रो को सकारात्मक शून्य में परिभाषित किया गया है।

NPY_HALF_PZERO

इस मैक्रो को सकारात्मक शून्य में परिभाषित किया गया है।

NPY_HALF_NZERO

यह स्थूल ऋणात्मक शून्य में परिभाषित होता है।

NPY_HALF_ONE

यह मैक्रो 1.0 को परिभाषित किया गया है।

NPY_HALF_NEGONE

यह मैक्रो -1.0 से परिभाषित होता है।

NPY_HALF_PINF

इस मैक्रो को + inf में परिभाषित किया गया है।

NPY_HALF_NINF

यह मैक्रो -inf से परिभाषित होता है।

NPY_HALF_NAN

इस मैक्रो को एक NaN मान के रूप में परिभाषित किया गया है, जो अपने साइन बिट के परेशान होने की गारंटी है।

float npy_half_to_float(npy_half h)

एक एकल-परिशुद्धता फ्लोट के लिए आधा-सटीक फ़्लोट को सम्मिलित करता है।

double npy_half_to_double(npy_half h)

एक अर्ध-परिशुद्धता फ्लोट को एक डबल-सटीक फ़्लोट में परिवर्तित करता है।

npy_half npy_float_to_half(float f)

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

npy_half npy_double_to_half(double d)

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

int npy_half_eq(npy_half h1, npy_half h2)

दो अर्ध-सटीक फ़्लोट्स की तुलना करता है (h1 == h2)।

int npy_half_ne(npy_half h1, npy_half h2)

दो अर्ध-सटीक फ्लोट्स की तुलना करता है (h1! = H2)।

int npy_half_le(npy_half h1, npy_half h2)

दो अर्ध-सटीक फ़्लोट्स की तुलना करता है (h1 <= h2)।

int npy_half_lt(npy_half h1, npy_half h2)

दो अर्ध-सटीक फ़्लोट्स की तुलना करता है (h1 <h2)।

int npy_half_ge(npy_half h1, npy_half h2)

दो अर्ध-सटीक फ़्लोट्स की तुलना करता है (h1> = h2)।

int npy_half_gt(npy_half h1, npy_half h2)

दो अर्ध-सटीक फ़्लोट्स की तुलना करता है (h1> h2)।

int npy_half_eq_nonan(npy_half h1, npy_half h2)

दो अर्ध-सटीक फ़्लोटों की तुलना करता है जिन्हें NaN (h1 == h2) नहीं होने के लिए जाना जाता है। यदि कोई मान NaN है, तो परिणाम अपरिभाषित है।

int npy_half_lt_nonan(npy_half h1, npy_half h2)

दो आधे-सटीक फ़्लोट्स की तुलना करता है जो NaN (h1 <h2) नहीं होने के लिए जाने जाते हैं। यदि कोई मान NaN है, तो परिणाम अपरिभाषित है।

int npy_half_le_nonan(npy_half h1, npy_half h2)

दो अर्ध-सटीक फ़्लोट्स की तुलना करता है जिन्हें NaN (h1 <= h2) नहीं होने के लिए जाना जाता है। यदि कोई मान NaN है, तो परिणाम अपरिभाषित है।

int npy_half_iszero(npy_half h)

टेस्ट कि क्या अर्ध-सटीक फ्लोट का मूल्य शून्य के बराबर है। यह npy_half_eq (h, NPY_ZERO) को कॉल करने से थोड़ा तेज़ हो सकता है।

int npy_half_isnan(npy_half h)

टेस्ट कि क्या आधा-सटीक फ्लोट एक NaN है।

int npy_half_isinf(npy_half h)

टेस्ट कि क्या अर्ध-सटीक फ्लोट प्लस या माइनस इन है।

int npy_half_isfinite(npy_half h)

टेस्ट कि क्या आधा परिशुद्धता फ्लोट परिमित है (NaN या Inf नहीं)।

int npy_half_signbit(npy_half h)

रिटर्न 1 ज h नेगेटिव है, 0 अन्यथा।

npy_half npy_half_copysign(npy_half x, npy_half y)

Y से कॉपी किए गए साइन बिट के साथ x का मान लौटाता है। Inf और NaN सहित किसी भी मूल्य के लिए काम करता है।

npy_half npy_half_spacing(npy_half h)

यह निम्‍न-स्‍तर के फ्लोटिंग प्‍वाइंट अनुभाग में वर्णित npy_spacing और npy_spacingf के रूप में आधे-सटीक फ्लोट के लिए समान है।

npy_half npy_half_nextafter(npy_half x, npy_half y)

यह निम्‍न-स्‍तर के फ्लोटिंग प्‍वाइंट सेक्शन में वर्णित npy_nextafter और npy_nextafterf के रूप में आधे-सटीक फ्लोट के लिए समान है।

npy_uint16 npy_floatbits_to_halfbits(npy_uint32 f)

निम्न-स्तरीय फ़ंक्शन जो एक 32-बिट एकल-सटीक फ्लोट को परिवर्तित करता है, जिसे यूइंट32 के रूप में संग्रहीत किया जाता है, 16-बिट आधा-सटीक फ्लोट में।

npy_uint16 npy_doublebits_to_halfbits(npy_uint64 d)

निम्न-स्तरीय फ़ंक्शन जो एक 64-बिट डबल-सटीक फ़्लोट को कनवर्ट करता है, जिसे यूइंट64 के रूप में संग्रहीत किया जाता है, 16-बिट आधा-सटीक फ़्लोट में।

npy_uint32 npy_halfbits_to_floatbits(npy_uint16 h)

निम्न-स्तरीय फ़ंक्शन जो एक 16-बिट आधा-सटीक फ़्लोट को 32-बिट एकल-सटीक फ़्लोट में परिवर्तित करता है, जिसे uv32 के रूप में संग्रहीत किया जाता है।

npy_uint64 npy_halfbits_to_doublebits(npy_uint16 h)

निम्न-स्तरीय फ़ंक्शन जो एक 16-बिट आधा-सटीक फ़्लोट को 64-बिट डबल-सटीक फ़्लोट में परिवर्तित करता है, जिसे uv64 के रूप में संग्रहीत किया जाता है।