डेटा.Sequence.Seq की तुलना में तेज़ी से कितनी तेज़ है []?

Question

स्पष्ट रूप से Seq सभी संभव संचालनों के लिए [] के रूप में asymptotically समान या बेहतर प्रदर्शन करता है। लेकिन चूंकि इसकी संरचना सूचियों की तुलना में अधिक जटिल है, छोटे आकारों के लिए इसके निरंतर ओवरहेड शायद इसे धीमा कर देगा। मैं कितना पता करने के लिए, विशेष रूप से करना चाहते हैं:

1. कितना धीमी <|: की तुलना में है?
2. Seq पर घुमावदार/ट्रैवर्सिंग [] (फोल्डिंग/ट्रैवर्सिंग फ़ंक्शन की लागत को छोड़कर) की तुलना में कितना धीमा हो रहा है/ट्रैवर्सिंग कितना धीमा हो रहा है?
3. आकार (लगभग) क्या है जिसके लिए \xs x -> xs ++ [x]|> से धीमा हो जाता है?
4. आकार (लगभग) क्या है जिसके लिए ++>< से धीमा हो जाता है?
5. viewl पर कॉल करने की लागत क्या है और सूची में मिलान पैटर्न की तुलना में परिणाम पर मिलान पैटर्न क्या है?
6. n -element Seqn -element list की तुलना में कितनी मेमोरी है? (स्मृति नहीं तत्वों, केवल संरचना के कब्जे में गिनती।)

मुझे पता है कि यह मापने के लिए, के बाद से Seq साथ हम परिशोधित जटिलता के बारे में बात मुश्किल है, लेकिन मैं कम से कम कुछ किसी न किसी संख्या जानना चाहते हैं । http://www.haskell.org/haskellwiki/Performance#Data.Sequence_vs._lists

एक अनुक्रम बराबर सूची के रूप में ज्यादा स्थान के रूप में 5/6 और 4/3 के बीच बार का उपयोग करता है (GHC में के रूप में प्रति नोड एक शब्द का एक ओवरहेड संभालने,) -

Answer 1

यह एक शुरुआत होनी चाहिए। यदि केवल डेक ऑपरेशंस का उपयोग किया जाता है, तो अंतरिक्ष का उपयोग सीमा के निचले सिरे के पास होगा, क्योंकि सभी आंतरिक नोड्स टर्नरी होंगे। विभाजन और संलग्न करने के भारी उपयोग के परिणामस्वरूप सूचियों के रूप में लगभग उसी स्थान का उपयोग किया जाएगा। विस्तार से:

• लंबाई एन की एक सूची में एन विपक्ष नोड्स शामिल हैं, प्रत्येक पर 3 शब्द हैं।
• लंबाई एन के अनुक्रम में लगभग n/(k-1) नोड्स हैं, जहां के आंतरिक नोड्स (प्रत्येक 2 या 3) की औसत धर्मार्थता है। प्रत्येक नोड के लिए एक पॉइंटर, आकार और ओवरहेड होता है, साथ ही प्रत्येक तत्व के लिए पॉइंटर, यानी एन (3/(के -1) + 1) शब्द।

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

Answer 2

मेरे पास उपरोक्त उत्तर में जोड़ने के लिए एक और ठोस परिणाम है। मैं एक लैंगविन समीकरण हल कर रहा हूँ। मैंने सूची और डेटा का उपयोग किया। पर्याप्तता। इस समाधान में सूची/अनुक्रम के पीछे बहुत से प्रविष्टियां चल रही हैं।

समेकित करने के लिए, मुझे गति में कोई सुधार नहीं हुआ, वास्तव में सीक्वेंस के साथ प्रदर्शन खराब हो गया। इसके अलावा डेटा.Sequence के साथ, मुझे Haskell आरटीएस के लिए उपलब्ध स्मृति को बढ़ाने की जरूरत है।

चूंकि मैं निश्चित रूप से अनुकूलित करने का अधिकार नहीं हूं; मैं नीचे दोनों मामलों को पोस्ट करता हूं। मुझे यह जानकर खुशी होगी कि क्या इसमें सुधार किया जा सकता है। दोनों कोड -O2 ध्वज के साथ संकलित किए गए थे।

1. Solution with List, लगभग 13.01 सेकंड
2. Solution with Data.Sequence लेता है, लगभग 15.13 सेकंड