numpy.ma.MaskedArray.strides

MaskedArray.strides

किसी सरणी को ट्रेस करते समय प्रत्येक आयाम में कदम रखने के लिए बाइट्स का ट्यूपल।

तत्व की बाइट ऑफ़सेट (i[0], i[1], ..., i[n]) एक सरणी में है a :

offset = sum(np.array(i) * a.strides)

NumPy संदर्भ गाइड में "ndarray.rst" फ़ाइल में स्ट्राइड्स का अधिक विस्तृत विवरण पाया जा सकता है।

यह भी देखें

numpy.lib.stride_tricks.as_strided

टिप्पणियाँ

32-बिट पूर्णांक (प्रत्येक 4 बाइट्स) की एक सरणी की कल्पना करें:

x = np.array([[0, 1, 2, 3, 4],
              [5, 6, 7, 8, 9]], dtype=np.int32)

इस सरणी को मेमोरी में 40 बाइट्स के रूप में संग्रहीत किया जाता है, एक के बाद एक (मेमोरी के एक सन्निहित ब्लॉक के रूप में जाना जाता है)। एक व्यूह के तार हमें बताते हैं कि एक निश्चित अक्ष के साथ अगली स्थिति में जाने के लिए हमें कितने बाइट्स को मेमोरी में छोड़ना पड़ता है। उदाहरण के लिए, हमें अगले कॉलम में जाने के लिए 4 बाइट्स (1 मान) को छोड़ना होगा, लेकिन अगली पंक्ति में समान स्थिति में आने के लिए 20 बाइट्स (5 मान)। जैसे, सरणी x लिए स्ट्राइड्स (20, 4) ।

उदाहरण

>>> y = np.reshape(np.arange(2*3*4), (2,3,4))
>>> y
array([[[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]],
       [[12, 13, 14, 15],
        [16, 17, 18, 19],
        [20, 21, 22, 23]]])
>>> y.strides
(48, 16, 4)
>>> y[1,1,1]
17
>>> offset=sum(y.strides * np.array((1,1,1)))
>>> offset/y.itemsize
17

>>> x = np.reshape(np.arange(5*6*7*8), (5,6,7,8)).transpose(2,3,1,0)
>>> x.strides
(32, 4, 224, 1344)
>>> i = np.array([3,5,2,2])
>>> offset = sum(i * x.strides)
>>> x[3,5,2,2]
813
>>> offset / x.itemsize
813