Numpy: जांचें कि फ़्लोट सरणी में पूरी संख्या

Question

पायथन में, यह जांचना संभव है कि float में n.is_integer() का उपयोग करके एक पूर्णांक मान है, जो इस QA: How to check if a float value is a whole number पर आधारित है।

क्या numpy के पास एक समान ऑपरेशन है जिसे सरणी पर लागू किया जा सकता है? कुछ ऐसा जो निम्नलिखित की अनुमति होगी:

>>> x = np.array([1.0 2.1 3.0 3.9]) 
>>> mask = np.is_integer(x) 
>>> mask 
array([True, False, True, False], dtype=bool) 

यह संभव है की तरह

>>> mask = (x == np.floor(x)) 

या

>>> mask = (x == np.round(x)) 

कुछ करने के लिए, लेकिन वे अतिरिक्त तरीकों बुला और अस्थायी सरणियों का एक समूह बनाने शामिल है कि संभावित रूप से टाला जा सकता है।

क्या numpy में वेक्टरकृत फ़ंक्शन है जो कि पाइथन के float.is_integer के समान फ्लोट के आंशिक हिस्सों की जांच करता है?

Answer 1

जो मैं कह सकता हूं उससे ऐसा कोई फ़ंक्शन नहीं है जो एक बुलियन सरणी देता है जो दर्शाता है कि क्या फ्लोट्स का एक अंश भाग है या नहीं। निकटतम मुझे मिल सकता है np.modf जो आंशिक और पूर्णांक भागों को लौटाता है, लेकिन यह दो फ्लोट सरणी (कम से कम अस्थायी रूप से) बनाता है, इसलिए यह सबसे अच्छी स्मृति-योग्य नहीं हो सकता है। गोल या मंजिल (जहां x के आसपास रखने के लिए) का उपयोग कर बनाम स्मृति को बचाने चाहिए

>>> np.mod(x, 1, out=x) 
>>> mask = (x == 0) 

यह, लेकिन निश्चित रूप से आप खो देते हैं:

आप जगह में काम कर खुश हैं, तो आप की तरह कुछ कोशिश कर सकते हैं मूल x।

दूसरा विकल्प यह है कि इसे नम्पी में लागू किया जाए, या इसे स्वयं लागू करें।

Answer 2

मुझे इस प्रश्न का उत्तर थोड़ा अलग कारण के लिए जरूरी था: जांच कर रहा हूं कि जब मैं डेटा खोने के बिना फ़्लोटिंग पॉइंट नंबरों की पूरी सरणी को पूर्णांक में परिवर्तित कर सकता हूं।

Hunse के जवाब लगभग मेरे लिए काम करता है, सिवाय इसके कि मैं स्पष्ट रूप से यथा-स्थान चाल का उपयोग नहीं कर सकते हैं, के बाद से मैं आपरेशन पूर्ववत करने के लिए सक्षम होना चाहिए:

if np.all(np.mod(x, 1) == 0): 
    x = x.astype(int) 

वहाँ से, मैं के बारे में सोचा निम्नलिखित विकल्प जो शायद कई स्थितियों में तेजी से होता है:

x_int = x.astype(int) 
if np.all((x - x_int) == 0): 
    x = x_int 

कारण यह है कि सापेक्ष आपरेशन घटाव की तुलना में धीमी है। हालांकि, अब हम सामने के पूर्णांक के लिए कास्टिंग करते हैं - मुझे नहीं पता कि ऑपरेशन कितनी तेजी से है, अपेक्षाकृत बोल रहा है। लेकिन अगर आपके एरे के अधिकांश पूर्णांक हैं (वे मेरे मामले में हैं), बाद वाला संस्करण लगभग निश्चित रूप से तेज़ है।

एक और लाभ यह है कि आप कुछ सहिष्णुता के भीतर जांचने के लिए np.isclose जैसे उपखंड को प्रतिस्थापित कर सकते हैं (बेशक आपको सावधान रहना चाहिए, क्योंकि छिड़काव उचित गोल नहीं है!)।

x_int = x.astype(int) 
if np.all(np.isclose(x, x_int, 0.0001)): 
    x = x_int 

संपादित करें: धीमी, लेकिन शायद यह आपके यूज-केस के आधार पर मूल्य, भी पूर्णांकों को व्यक्तिगत रूप से उपस्थित अगर परिवर्तित।

x_int = x.astype(int) 
safe_conversion = (x - x_int) == 0 
# if we can convert the whole array to integers, do that 
if np.all(safe_conversion): 
    x = x_int.tolist() 
else: 
    x = x.tolist() 
    # if there are _some_ integers, convert them 
    if np.any(safe_conversion): 
     for i in range(len(x)): 
      if safe_conversion[i]: 
       x[i] = int(x[i]) 

जहां इस मायने रखती का एक उदाहरण के रूप में: यह मेरे लिए बाहर काम करता है, क्योंकि मैं विरल डेटा (जो ज्यादातर शून्य का मतलब है), जो मैं तो JSON में बदलने का है, एक बार, और बाद में एक सर्वर पर पुन: उपयोग। फ्लोट्स के लिए, ujson उन्हें [ ...,0.0,0.0,0.0,... ] के रूप में परिवर्तित करता है, और इनट्स के लिए [...,0,0,0,...] में परिणाम होता है, जो स्ट्रिंग में वर्णों की आधा संख्याओं को बचाता है। यह दोनों सर्वर (छोटे तार) और क्लाइंट (छोटे तारों, संभवतः थोड़ा तेज़ JSON पार्सिंग) पर ओवरहेड को कम करता है।