Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> Python

पायथन में ऐरे एलिमेंट्स के इनवर्स हाइपरबोलिक कोसाइन की गणना करना


आर्ककोश (arccosh) एक मल्टीवैल्यूड फंक्शन है: प्रत्येक x के लिए अनंत संख्याएँ z होती हैं जैसे कि cosh(z) = x। कन्वेंशन यह है कि उस z को लौटाया जाए जिसका काल्पनिक भाग [-pi, pi] में हो और वास्तविक भाग [0, inf] में हो। रियल-वैल्यूड इनपुट डेटा टाइप्स के लिए, arccosh हमेशा रियल आउटपुट लौटाता है। प्रत्येक मान के लिए जिसे रियल नंबर या इन्फिनिटी के रूप में व्यक्त नहीं किया जा सकता, यह nan देता है और इनवैलिड फ्लोटिंग पॉइंट एरर फ्लैग सेट करता है। कॉम्प्लेक्स-वैल्यूड इनपुट के लिए, arccosh एक कॉम्प्लेक्स एनालिटिकल फंक्शन है जिसकी ब्रांच कट [-inf, 1] है और उस पर ऊपर से कंटीन्यूअस है।

ऐरे एलिमेंट्स के इनवर्स हाइपरबोलिक कोसाइन की गणना करने के लिए, numpy.arccosh() मेथड का उपयोग करें। मेथड x के समान आकार का ऐरे लौटाता है। यदि x स्केलर है तो यह स्केलर होता है। पहला पैरामीटर, x इनपुट ऐरे है। दूसरा और तीसरा पैरामीटर वैकल्पिक हैं।

दूसरा पैरामीटर एक ndarray है, वह स्थान जहां परिणाम संग्रहीत होता है। यदि प्रदान किया गया है, तो इसका आकार ऐसा होना चाहिए जिसे इनपुट्स में ब्रॉडकास्ट किया जा सके। यदि प्रदान नहीं किया गया या None है, तो एक नया आवंटित ऐरे लौटाया जाता है। तीसरा पैरामीटर कंडीशन है जिसे इनपुट पर ब्रॉडकास्ट किया जाता है। जिन स्थानों पर कंडीशन True होती है, वहां आउट ऐरे को ufunc परिणाम पर सेट किया जाएगा। अन्यथा, आउट ऐरे अपना मूल मान बनाए रखेगा।

चरण

सबसे पहले, आवश्यक लाइब्रेरी इम्पोर्ट करें:

import numpy as np

नम्पाई में array() मेथड का उपयोग करके एक ऐरे बनाएं:

arr = np.array((0., 30., 45., 60., 90., 180., np.pi*1j/2, np.pi*1j))

हमारा ऐरे प्रदर्शित करें:

print("ऐरे...\n", arr)

डेटा टाइप प्राप्त करें:

print("\nऐरे डेटा टाइप...\n", arr.dtype)

ऐरे के आयाम प्राप्त करें:

print("\nऐरे आयाम...\n", arr.ndim)

ऐरे के एलिमेंट्स की संख्या प्राप्त करें:

print("\nऐरे में एलिमेंट्स की संख्या...\n", arr.size)

ऐरे एलिमेंट्स के इनवर्स हाइपरबोलिक कोसाइन को खोजने के लिए, पायथन नम्पाई में numpy.arccosh() मेथड का उपयोग करें:

print("\nपरिणाम...", np.arccosh(arr))

उदाहरण

import numpy as np
# ऐरे एलिमेंट्स के इनवर्स हाइपरबोलिक कोसाइन की गणना करने के लिए, पायथन नम्पाई में numpy.arccosh() मेथड का उपयोग करें
# मेथड x के समान आकार का ऐरे लौटाता है। यदि x स्केलर है तो यह स्केलर होता है।
print("ऐरे एलिमेंट्स के ट्राइगोनोमेट्रिक इनवर्स हाइपरबोलिक कोसाइन प्राप्त करें...")
# नम्पाई में array() मेथड का उपयोग करके एक ऐरे बनाना
arr = np.array((0., 30., 45., 60., 90., 180., np.pi*1j/2, np.pi*1j))
# ऐरे प्रदर्शित करना
print("ऐरे...\n", arr)
# ऐरे का प्रकार प्राप्त करना
print("\nहमारे ऐरे का प्रकार...\n", arr.dtype)
# ऐरे के आयाम प्राप्त करना
print("\nहमारे ऐरे आयाम...\n", arr.ndim)
# ऐरे में एलिमेंट्स की संख्या प्राप्त करना
print("\nएलिमेंट्स की संख्या...\n", arr.size)
# ऐरे एलिमेंट्स के इनवर्स हाइपरबोलिक कोसाइन को खोजने के लिए, पायथन नम्पाई में numpy.arccosh() मेथड का उपयोग करें
print("\nपरिणाम...", np.arccosh(arr))

आउटपुट

ऐरे एलिमेंट्स के ट्राइगोनोमेट्रिक इनवर्स हाइपरबोलिक कोसाइन प्राप्त करें... ऐरे... [ 0.+0.j 30.+0.j 45.+0.j 60.+0.j 90.+0.j 180.+0.j 0.+1.57079633j 0.+3.14159265j] हमारे ऐरे का प्रकार... complex128 हमारे ऐरे आयाम... 1 एलिमेंट्स की संख्या... 8 परिणाम... [0. +1.57079633j 4.09406667+0.j 4.49968619+0.j 4.78742229+0.j 5.19292599+0.j 5.88609632+0.j 1.23340312+1.57079633j 1.86229574+1.57079633j]

  1. - पायथन में सरणी का डिटरमिनेंट निकालना

    रैखिक बीजगणित में सरणी का डिटरमिनेंट निकालने के लिए, पायथन NumPy में np.linalg.det() का उपयोग करें। पहला पैरामीटर a वह इनपुट सरणी है जिसके लिए डिटरमिनेंट की गणना की जाती है। यह विधि डिटरमिनेंट लौटाती है। चरण सबसे पहले, आवश्यक लाइब्रेरी आयात करें: import numpy as np एक सरणी बनाएं: arr = np.array([[

  1. - पायथन में सरणी तत्वों का त्रिकोणमितीय व्युत्क्रम साइन प्राप्त करना

    आर्कसाइन (arcsin) एक बहुमूल्य फ़ंक्शन है: प्रत्येक x के लिए अनंत संख्या में z होते हैं जैसे कि sin(z) = x। परंपरा यह है कि उस कोण z को लौटाया जाए जिसका वास्तविक भाग [-pi/2, pi/2] में हो। व्युत्क्रम साइन को asin या sin⁻¹ के नाम से भी जाना जाता है। वास्तविक-मूल्य इनपुट डेटा प्रकार के लिए, arcsin हमेश

  1. - पायथन में ऐरे एलिमेंट्स का हाइपरबोलिक टैंजेंट निकालें

    पायथन नम्पी में ऐरे एलिमेंट्स का हाइपरबोलिक टैंजेंट निकालने के लिए numpy.tanh() मेथड का उपयोग करें। यह मेथड np.sinh(x)/np.cosh(x) या -1j * np.tan(1j*x) के बराबर है। संबंधित हाइपरबोलिक टैंजेंट मान लौटाता है। यदि x स्केलर है तो यह स्केलर होता है। पहला पैरामीटर x इनपुट ऐरे है। दूसरा और तीसरा पैरामीटर