numpy
numpy.cross

algorithm C Language C++ MATLAB Language matplotlib opencv pandas Python Language R Language tensorflow
खोज…


वाक्य - विन्यास

  • numpy.cross(a, b) # a और b का क्रॉस उत्पाद (या a और b में वैक्टर)
  • numpy.cross(a, b, axisa=-1) a के साथ वैक्टर के उत्पाद b , st वैक्टर में एक अक्ष अक्ष के साथ बाहर रखे जाते हैं
  • numpy.cross(a, b, axisa=-1, axisb=-1, axisc=-1) # a और b में वैक्टर के क्रॉस प्रोडक्ट्स, आउटपुट वैक्टर एक्सिस द्वारा निर्दिष्ट अक्ष के साथ बिछाए गए
  • numpy.cross(a, b, axis=None) # a और b में वैक्टर के क्रॉस उत्पाद, a , b में वैक्टर, और अक्ष अक्ष के साथ आउटपुट में

पैरामीटर

स्तंभ स्तंभ
ए, बी सरलतम उपयोग में, a और b दो 2- या 3-तत्व वैक्टर हैं। वे वैक्टर (यानी द्वि-आयामी मैट्रिक्स) के एरे भी हो सकते हैं। यदि a एक सरणी और 'बी' है एक वेक्टर, है cross(a,b) एक सरणी जिसका तत्वों में प्रत्येक वेक्टर के पार उत्पादों रहे हैं रिटर्न a वेक्टर के साथ b । b एक सरणी है और a एक भी वेक्टर, है cross(a,b) रिटर्न एक सरणी जिसका तत्वों के पार उत्पादों रहे हैं a में प्रत्येक वेक्टर के साथ b । a और b दोनों एक ही आकार होने पर सरणियाँ हो सकती हैं। इस स्थिति में, cross(a,b) रिटर्न cross(a[0],b[0]), cross(a[1], b[1]), ...
axisa / b यदि a एक सरणी है, यह सबसे तेजी से बदलती धुरी, धीमी परिवर्तनीय अक्ष, या बीच में कुछ भर में बाहर रखी वैक्टर हो सकता है। axisa cross() बताती है कि कैसे वैक्टर को अंदर रखा जाता a । डिफ़ॉल्ट रूप से, यह सबसे धीरे-धीरे बदलती अक्ष का मान लेता है। axisb इनपुट b साथ ही काम करता है। यदि cross() का आउटपुट एक सरणी होने जा रहा है, तो आउटपुट वैक्टर को अलग-अलग सरणी अक्षों पर रखा जा सकता है; axisc बताता cross कैसे बाहर इसके उत्पादन सरणी में वैक्टर रखना। डिफ़ॉल्ट रूप से, axisc सबसे धीरे-धीरे बदलती अक्ष को इंगित करता है।
एक्सिस एक सुविधा पैरामीटर जो axisa , axisb , और axisc सेट करता है यदि वांछित है। यदि कॉल में axis और कोई अन्य पैरामीटर मौजूद हैं, तो axis का मान अन्य मानों को ओवरराइड करेगा।

दो वैक्टर का क्रॉस उत्पाद

Numpy वेक्टर क्रॉस उत्पादों की गणना के लिए एक cross फ़ंक्शन प्रदान करता है। वैक्टर [1, 0, 0] और [0, 1, 0] का क्रॉस उत्पाद [0, 0, 1] । Numpy हमें बताता है: 

>>> a = np.array([1, 0, 0])
>>> b = np.array([0, 1, 0])
>>> np.cross(a, b)
array([0, 0, 1])

जैसा सोचा था।

जबकि क्रॉस उत्पाद सामान्य रूप से केवल तीन आयामी वैक्टर के लिए परिभाषित होते हैं। हालाँकि, Numpy फ़ंक्शन के लिए दोनों तर्कों में दो तत्व वैक्टर हो सकते हैं। यदि वेक्टर c को [c1, c2] रूप में दिया जाता है, तो Numpy तीसरे आयाम को शून्य प्रदान करता है: [c1, c2, 0] । इसलिए, 

>>> c = np.array([0, 2])
>>> np.cross(a, c)
array([0, 0, 2])

विपरीत dot जो दोनों एक के रूप में मौजूद Numpy समारोह और एक की विधि ndarray , cross केवल एक स्टैंडअलोन समारोह के रूप में मौजूद है: 

>>> a.cross(b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'numpy.ndarray' object has no attribute 'cross'

एक कॉल के साथ कई क्रॉस उत्पाद

या तो इनपुट 3- (या 2-) तत्व वैक्टर का एक सरणी हो सकता है। 

>>> a=np.array([[1,0,0],[0,1,0],[0,0,1]])
>>> b=np.array([1,0,0])
>>> np.cross(a,b)
array([[ 0,  0,  0],
       [ 0,  0, -1],
       [ 0,  1,  0]])

इस मामले में परिणाम सरणी ([np.cross (a [0], b), np.cross ([1], b), np.cross ([2], b)] है

b भी 3- (या 2-) तत्व वैक्टर का एक सरणी हो सकता है, लेकिन इसका आकार a जैसा होना चाहिए। अन्यथा गणना "आकार बेमेल" त्रुटि के साथ विफल हो जाती है। तो हम कर सकते हैं 

>>> b=np.array([[0,0,1],[1,0,0],[0,1,0]])
>>> np.cross(a,b)
array([[ 0, -1,  0],
       [ 0,  0, -1],
       [-1,  0,  0]])

और अब परिणाम array([np.cross(a[0],b[0]), np.cross(a[1],b[1]), np.cross(a[2],b[2])])

मल्टीपल क्रॉस प्रोडक्ट्स के साथ अधिक लचीलापन

हमारे पिछले दो उदाहरणों में, सुन्न ने यह माना कि a[0,:] पहला वेक्टर था, a[1,:] दूसरा, और a[2,:] तीसरा। Numpy.cross में एक वैकल्पिक तर्क कुल्हाड़ी है जो हमें निर्दिष्ट करने की अनुमति देती है कि कौन सा अक्ष वैक्टर को परिभाषित करता है। इसलिए, 

>>> a=np.array([[1,1,1],[0,1,0],[1,0,-1]])
>>> b=np.array([0,0,1])
>>> np.cross(a,b)
array([[ 1, -1,  0],
       [ 1,  0,  0],
       [ 0, -1,  0]])
>>> np.cross(a,b,axisa=0)
array([[ 0, -1,  0],
       [ 1, -1,  0],
       [ 0, -1,  0]])
>>> np.cross(a,b,axisa=1)
array([[ 1, -1,  0],
       [ 1,  0,  0],
       [ 0, -1,  0]])

axisa=1 परिणाम और डिफ़ॉल्ट परिणाम दोनों हैं (np.cross([1,1,1],b), np.cross([0,1,0],b), np.cross([1,0,-1],b)) । डिफ़ॉल्ट रूप से, axisa हमेशा axisa के अंतिम (सबसे धीरे-धीरे बदलती) अक्ष को इंगित करती है। axisa=0 परिणाम (np.cross([1,0,1],b), np.cross([1,1,0],b), np.cross([1,0,-1],b)) ।

एक समान वैकल्पिक पैरामीटर, axisb , b इनपुट के लिए एक ही फ़ंक्शन करता है, अगर यह 2-आयामी सरणी भी है।

पैरामीटर एक्सिसा और एक्सिस इनपुट डेटा को वितरित करने के लिए कैसे खस्ता बताती हैं। एक तीसरा पैरामीटर, एक्सिस सुन्न बताता है कि आउटपुट को कैसे वितरित किया जाए यदि a या b बहु-आयामी है। ऊपर के रूप में a ही इनपुट और b का उपयोग करना, हम प्राप्त करते हैं 

>>> np.cross(a,b,1)
array([[ 1, -1,  0],
       [ 1,  0,  0],
       [ 0, -1,  0]])
>>> np.cross(a,b,1,axisc=0)
array([[ 1,  1,  0],
       [-1,  0, -1],
       [ 0,  0,  0]])
>>> np.cross(a,b,1,axisc=1)
array([[ 1, -1,  0],
       [ 1,  0,  0],
       [ 0, -1,  0]])

तो axisc=1 और डिफ़ॉल्ट axisc दोनों एक ही परिणाम देते हैं, axisc , प्रत्येक वेक्टर के तत्व आउटपुट सरणी के सबसे तेज़ गतिमान सूचकांक में सन्निहित हैं। axisc डिफ़ॉल्ट रूप से सरणी के अंतिम अक्ष है। axisc=0 प्रत्येक वेक्टर के तत्वों को सरणी के सबसे धीमे अलग-अलग आयाम में वितरित करता है।

यदि आप axisa , axisb , और axisc सभी को समान मान चाहते हैं, तो आपको सभी तीन पैरामीटर सेट करने की आवश्यकता नहीं है। आप एक एकल मान के लिए चौथा पैरामीटर, axis , सेट कर सकते हैं और अन्य तीन पैरामीटर स्वचालित रूप से सेट हो जाएंगे। अक्ष अक्ष, अक्ष, अक्ष या अक्षरेखा को ओवरराइड करता है यदि उनमें से कोई भी फ़ंक्शन कॉल में मौजूद है।



Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow