सूची पुनरावृत्ति में एकाधिक मैचों को रोकना

Question

मैं पाइथन के लिए अपेक्षाकृत नया हूं, इसलिए मैं यह समझाने के लिए अपनी पूरी कोशिश करूंगा कि मैं क्या करने की कोशिश कर रहा हूं। मैं सितारों की दो सूचियों (जिसमें दोनों रिकॉर्ड एरे होते हैं) के माध्यम से पुनरावृत्ति करने की कोशिश कर रहे हैं, सहिष्णुता के साथ अपने निर्देशांक द्वारा सितारों से मिलान करने की कोशिश कर रहे हैं (इस मामले में रा और दिसंबर, जो रिकॉर्ड एरे के अंदर दोनों सूचकांक हैं)। हालांकि, एक सूची से कई सितारे दिखाई देते हैं जो दूसरे में एक ही स्टार से मेल खाते हैं। * यह एटोल के भीतर मिलान करने वाले दोनों सितारों के कारण है। क्या इसको रोकने के लिए कोई रास्ता है? यहां मेरे पास अब तक है:

from __future__ import print_function 
import numpy as np  

###importing data### 
Astars = list() 
for s in ApStars:###this is imported but not shown 
    Astars.append(s) 

wStars = list() 
data1 = np.genfromtxt('6819.txt', dtype=None, delimiter=',', names=True) 
for star in data1: 
    wStars.append(star) 

###beginning matching stars between the Astars and wStars### 
list1 = list() 
list2 = list() 
for star,s in [(star,s) for star in wStars for s in Astars]: 
    if np.logical_and(np.isclose(s["RA"],star["RA"], atol=0.000277778)==True , 
         np.isclose(s["DEC"],star["DEC"],atol=0.000277778)==True): 
     if star not in list1: 
      list1.append(star) #matched wStars 
     if s not in list2: 
      list2.append(s) #matched Astars 

मैं एटोल को कम नहीं कर सकता क्योंकि यह वाद्य यंत्र से परे है। यह क्या होता है: एक एस्टार से मेल खाने वाले कई Wstars हैं। यदि यह संभव है तो मैं सिर्फ एक स्टार के लिए एक सितारा चाहता हूं।

कोई सुझाव?

Answer 1

मैं आपके द्वारा प्रदान किए गए सभी की सराहना करता हूं! मैंने कुछ लोगों को भी आसपास से पूछा और जो कुछ मैं खोज रहा था उसे पूरा करने के लिए एक चालाक तरीका मिला।

sharedStarsW = list() 
sharedStarsA = list() 
for s in Astars: 
    distance = [((s["RA"] - star["RA"])**2 + (s["DEC"] - star["DEC"])**2)**0.5 for star in wStars] 
    if np.amin(distance) < 0.00009259266: 
     sharedStarsW.append(wStars[(np.argmin(distance))]) 
     sharedStarsA.append(s) 

सूची समझ का उपयोग करना, यह सब wStars के लिए एक Astar से दूरी की गणना करता है और कि 1/3 arcsecond में आते हैं उन सभी को ले जाता है: यहाँ है कि हम क्या के साथ आया है। यदि एक एस्टार स्टार में कई WStars मैचों हैं, तो यह वस्टर इंडेक्स को जोड़ता है जो सबसे छोटी दूरी और इसके Astar देता है।

Answer 2

पहली बार यहां एक प्रश्न का उत्तर देने (अगर मैंने कोई गलती की है तो कृपया संकेत दें)। लेकिन ऐसा लगता है कि डेविड ने जो टिप्पणी की वह सही है "स्टार हमेशा सूची 1 में है (और एस हमेशा सूची 2 में है। तो मैं की तुलना और एक newlist1/newlist1 कि स्टार और एस का ट्रैक रखता है के लिए जोड़कर सुझाव है।

newlist1 = list() 
newlist2 = list() 

#new list will keep the unique star and s 
for star in list1: 
    for s in list2: 
     #assuming the comparison works haven't test it yet 
     if np.logical_and(np.isclose(s["RA"],star["RA"], atol=0.000277778)==True , np.isclose(s["DEC"],star["DEC"],atol=0.000277778)==True): 
       if star not in newlist1: 
        newlist1.append(s) 
       if s not in newlist2: 
        newlist2.append(s) 
       break 
       #once a match is found leave the second loop 

Answer 3

मैं अपने दृष्टिकोण पूरी तरह से बदलने के तथ्य यह है कि इन खगोलीय पिंडों की बात कर रहे हैं फिट करने के लिए होगा। मैं लोड हो रहा है पर ध्यान नहीं देगा कार्यक्षमता और मान लें कि आपके पास पहले से ही आपकी इनपुट सूचियां Astar और wStar हैं।

हमें निकटतमwStar में Astar में प्रत्येक स्टार को कार्टेशियन डॉट उत्पाद का उपयोग करके मिलेगा। सर्वोत्तम मिलान के बारे में किसी भी अस्पष्टता को हल करने में मदद करें।

# Pre-process the data a little 
def getCV(ra, de): 
    return np.array([np.cos(aStar['DE']) * np.cos(aStar['RA']), 
        np.cos(aStar['DE']) * np.sin(aStar['RA']), 
        np.sin(aStar['DE'])]) 

for aStar in Astars: 
    aStar['CV'] = getCV(aStar['RA'], aStar['DE']) 
for wStar in wStars: 
    wStar['CV'] = getCV(wStar['RA'], wStar['DE']) 

# Construct lists of matching stars 
aList = [] 
wList = [] 

# This an extra list of lists of stars that are within tolerance but are 
# not best matches. This list will contain empty sublists, but never None 
wCandidates [] 

for aStar in AStars: 
    for wStar in wStars: 
     # Use native short-circuiting, and don't explicitly test for `True` 
     if np.isclose(aStar["RA"], wStar["RA"], atol=0.000277778) and \ 
      np.isclose(aStar["DEC"], wStar["DEC"], atol=0.000277778): 
      newDot = np.dot(aStar['CV'], wStar['CV']) 
      if aStar == aList[-1]: 
       # This star already has a match, possibly update it 
       if newDot > bestDot: 
        bestDot = newDot 
        # Move the previous best match to list of candidates 
        wCandidates[-1].append(wList[-1]) 
        wList[-1] = wStar 
       else: 
        wCandidates[-1].append(wStar) 
      else: 
       # This star does not yet have a match 
       bestDot = newDot 
       aList.append(aStar) 
       wList.append(wStar) 
       wCandidates.append([]) 

नतीजा यह है कि wList में प्रत्येक सूचकांक में सितारों aList में इसी स्टार के लिए सबसे अच्छा मैच का प्रतिनिधित्व करते है। सभी सितारों के पास एक मैच नहीं है, इसलिए सभी सितारों में से कोई भी सूची में दिखाई नहीं देगी। ध्यान दें कि कुछ (बहुत ही असंभव) मामले हो सकते हैं जहां aList में एक स्टार wList में से एक के लिए सबसे अच्छा मिलान नहीं है।

हमें these formulas के आधार पर कार्टेशियन यूनिट वैक्टरों की गणना करके और डॉट उत्पाद लेने के द्वारा दो सितारों के बीच निकटतम पूर्ण दूरी मिलती है। डॉट के करीब एक है, सितारों के करीब एक साथ हैं। इससे अस्पष्टताओं को हल करने में मदद मिलनी चाहिए।

मैंने wStars के लिए इसे और अधिक करने से बचने के लिए मुख्य लूप के बाहर सितारों के लिए कार्टेशियन वैक्टरों की पूर्व-गणना की। कुंजी नाम 'CV' कार्टेशियन वेक्टर के लिए खड़ा है। जैसा कि आप फिट देखते हैं इसे बदलें।

अंतिम नोट, यह विधि यह नहीं जांचती है कि wStars से एक स्टार एक से अधिक AStar के साथ मेल खाता है। यह सुनिश्चित करता है कि प्रत्येक AStar के लिए सर्वोत्तम wStar चुना गया है।

अद्यतन

मैं उत्पादन है, जो सभी wStars उम्मीदवारों कि इसी AStars तत्व की सहिष्णुता के भीतर थे सूचीबद्ध करता है करने के लिए एक तीसरी सूची जोड़ा है, लेकिन सबसे अच्छा मैच के रूप में चुना नहीं जा सके थे।

Answer 4

मैंने आपके मुद्दों को पूरी तरह से अवशोषित नहीं किया है, लेकिन मैं आपकी गणना को सरल बनाने की कोशिश करने के साथ शुरू करूंगा।

Apstars और data1 की तरह दिखता है संरचित सरणी, दोनों dtype के साथ 1 डी दोनों हैं।

इस सूची में यात्रा के साथ प्रतिस्थापित किया जा सकता:

Astars = list() 
for s in ApStars:###this is imported but not shown 
    Astars.append(s) 

साथ

Astarrs = list(ApStars) 

या बस छोड़े गए। यदि आप यहां ApStars पर पुनरावृत्त कर सकते हैं, तो आप सूची समझ में उन पर पुन: प्रयास कर सकते हैं। wStars के लिए वही। ,

set1, set2 = set(), set() 
# for star,s in [(star,s) for star in data1 for s in ApStars]: 
# iteration on this list comprehension works, 
# but I think this nest iteration is clearer 
for star in data1: 
    for s in ApStars: 
     x1 = np.isclose(s["RA"],star["RA"], atol=0.000277778) 
     x2 = np.isclose(s["DEC"],star["DEC"],atol=0.000277778) 
     # isclose returns boolean, don't need the ==True 
     if x1 & x2: 
      set1.add(star) 
      set2.add(s) 

प्रतिस्थापन के बिना जोड़ा जा रहा है set करना आसान है, हालांकि क्रम निर्धारित नहीं है (dict के साथ के रूप में ही):

मैं तुलना पुनर्लेखन चाहते हैं के रूप में।

मैं यह जानना चाहता हूं कि पुनरावृत्ति से पहले प्रासंगिक फ़ील्ड 'निकालने' से मदद मिलेगी या नहीं।

Apstars['RA'], data1['RA'], Apstars['DEC'], data1['DEC'] 

x1 = np.isclose(Apstars['RA'][:,None], data1['RA'], atol=...) 
x2 = np.isclose(Apstars['DEC']....) 

x12 = x1 & x2 

x12 एक 2 डी बूलियन सरणी है; x12[i,j] सत्य है जब Apstars[i]data1[j] पर 'बंद करें' है।