मैं मंद-मंद अज्ञेयवादी कोड कैसे लिखूं?

Question

मैं अक्सर खुद को एक दिए गए ऑपरेशन / एल्गोरिथ्म के एक, दो और तीन आयामी संस्करणों के लिए बहुत समान कोड लिखता हुआ पाता हूं। इन सभी संस्करणों को बनाए रखना थकाऊ बन सकता है। सरल कोड पीढ़ी काफी अच्छी तरह से काम करती है, लेकिन ऐसा लगता है कि एक बेहतर तरीका होना चाहिए।

क्या एक बार ऑपरेशन लिखने का अपेक्षाकृत सरल तरीका है और क्या यह उच्च या निम्न आयामों के लिए सामान्य है?

एक ठोस उदाहरण है: मान लीजिए कि मुझे वर्णक्रमीय अंतरिक्ष में एक वेग क्षेत्र की ढाल की गणना करने की आवश्यकता है। तीन आयामों में, फोरट्रान छोर कुछ इस तरह दिखाई देंगे:

do k = 1, n
  do j = 1, n
    do i = 1, n
      phi(i,j,k) = ddx(i)*u(i,j,k) + ddx(j)*v(i,j,k) + ddx(k)*w(i,j,k)
    end do
  end do
end do

जहां ddxसरणी को उचित रूप से परिभाषित किया गया है। (मैट्रिक्स मैट्रिक्स के साथ भी कोई ऐसा कर सकता है।) द्वि-आयामी प्रवाह के लिए कोड लगभग बिल्कुल समान है, सिवाय इसके: तीसरा आयाम छोरों, अनुक्रमित और घटकों की संख्या से गिरा दिया गया है। क्या इसे व्यक्त करने का एक बेहतर तरीका है?

एक अन्य उदाहरण है: मान लीजिए कि मेरे पास तीन आयामी ग्रिड पर तरल-वेग परिभाषित बिंदु-वार हैं। एक अनियंत्रित स्थान (यानी, ग्रिड बिंदुओं के अनुरूप नहीं) के वेग को प्रक्षेपित करने के लिए, व्यक्ति तीन आयामी (यानी, आयामी कमी) पर एक आयामी नेविल एल्गोरिथम का क्रमिक रूप से उपयोग कर सकता है । क्या एक सरल एल्गोरिथ्म के एक आयामी कार्यान्वयन को देखते हुए आयामी कमी करने का एक आसान तरीका है?

Answer 1

आप यह देखते हैं कि कैसे deal.II ( http://www.dealii.org/ ) करता है - वहां, आयाम स्वतंत्रता पुस्तकालय के बहुत दिल में स्थित है, और इसे अधिकांश डेटा प्रकारों के लिए टेम्पलेट तर्क के रूप में तैयार किया गया है। उदाहरण के लिए, चरण -4 ट्यूटोरियल कार्यक्रम में आयाम-अज्ञेय लाप्लास सॉल्वर:

http://www.dealii.org/developer/doxygen/deal.II/step_4.html

यह सभी देखें

https://github.com/dealii/dealii/wiki/Frequently-Asked-Questions#why-use-templates-for-the-space-dimension

Comments

मै पूरी तरह से सहमत हूँ। मुझे Deal.II की तुलना में बेहतर दृष्टिकोण नहीं मिला है। वे इस समस्या को हल करने के लिए बहुत ही रोचक तरीके से टेम्प्लेट का उपयोग करते हैं।

— एल्डिला

एक अच्छा संसाधन, लेकिन अगर आप C ++ टेम्प्लेट को ग्रो नहीं करते हैं, तो बहुत डराने वाला है।

— मेवप्लप

@ वोल्फगैंग बंगर्थ: क्या डील.आई टेम्प्लेट का उपयोग करते हुए पुनरावृत्तियों को परिभाषित करता है?

— मैथ्यू एम्मेट

@MatthewEmmett: हाँ।

— वोल्फगैंग बैंगर्थ

@meawoppl: वास्तव में, नहीं। मैं नियमित रूप से deal.II पर कक्षाएं सिखाता हूं, और शुरुआत में छात्रों को केवल यह बताता हूं कि ClassWhatever <2> 2d में जो कुछ भी है वह सब कुछ है, ClassWhatever <3> 3 डी में है, और ClassWhatever <मंद> मंद-डी में है। मैं सप्ताह 3 में कहीं भी पाठों पर पाठ लाता हूं, और जब यह संभावना होती है कि छात्र यह नहीं समझते कि इससे पहले यह कैसे काम करता है, तो वे वैसे भी इसका पूरी तरह से उपयोग करते हैं।

— वोल्फगैंग बैंगर्थ

Answer 2

यह सवाल उजागर करता है कि अधिकांश "सादे" प्रोग्रामिंग भाषाएं (सी, फोरट्रान, कम से कम) आपको यह सफाई से करने की अनुमति नहीं देती हैं। एक अतिरिक्त बाधा यह है कि आप उल्लेखनीय सुविधा और अच्छा प्रदर्शन चाहते हैं।

इसलिए, एक आयाम-विशिष्ट कोड लिखने के बजाय , एक कोड लिखने पर विचार करें जो एक आयाम-विशिष्ट कोड उत्पन्न करता है। यह जनरेटर आयाम-स्वतंत्र है, भले ही गणना कोड नहीं है। दूसरे शब्दों में, आप अपने अंकन और गणना को व्यक्त करने वाले कोड के बीच तर्क की एक परत जोड़ते हैं। C ++ टेम्प्लेट में एक ही चीज़ होती है: उल्टा, वे सही भाषा में निर्मित होते हैं। नीचे, वे कुछ हद तक बोझिल हैं। यह प्रश्न को कम करता है कि कोड जनरेटर को व्यावहारिक रूप से कैसे महसूस किया जाए।

OpenCL आपको रन जनरेशन पर कोड जेनरेशन को काफी सफाई से करने देता है। यह 'बाहरी नियंत्रण कार्यक्रम' और 'आंतरिक छोरों / गुठली' के बीच एक बहुत साफ विभाजन के लिए भी बनाता है। बाहरी, उत्पन्न करने वाला कार्यक्रम बहुत कम प्रदर्शन-विवश है, और इसलिए इसे पायथन जैसे कम्फर्टेबल भाषा में लिखा जा सकता है। यह मेरी आशा है कि PyOpenCL का उपयोग कैसे किया जाएगा - नए सिरे से बेशर्म प्लग के लिए क्षमा करें।

Comments

एंड्रियास! Scicomp में आपका स्वागत है! खुशी है कि आप साइट पर हैं, मुझे लगता है कि आप जानते हैं कि यदि आपके कोई प्रश्न हैं तो मेरे साथ कैसे संपर्क करें।

— एरन अहमदिया

C ++ जादू के बजाय इस समस्या के समाधान के रूप में स्वचालित कोड पीढ़ी के लिए +10000।

— जेफ

Answer 3

इसे किसी भी भाषा में निम्नलिखित मोटे मानसिक प्रोटोटाइप के साथ पूरा किया जा सकता है:

1. MATLAB मुझे लगता है कि प्रत्येक आयाम (कुछ की तरह आकार) के extents की एक सूची बनाएँ
2. प्रत्येक आयाम में अपने वर्तमान स्थान की एक सूची बनाएँ।
3. प्रत्येक आयाम पर एक लूप लिखें, जिसमें बाहरी लूप के आधार पर पूर्ण आकार के बदलाव पर एक लूप हो।

वहां से, यह आपके कोड nd-compliant को बनाए रखने के लिए आपकी निश्चित भाषा के सिंटैक्स से जूझने का सवाल है।

एक एन-डायमेंशनल फ्लूड-डायनेमिक्स सॉल्वर लिखा होने के बाद , मैंने पाया है कि यह एक ऐसी भाषा के लिए सहायक है जो किसी फ़ंक्शन की तर्क के रूप में ऑब्जेक्ट जैसी सूची को अनपैकिंग का समर्थन करती है। Ie a = (1,2,3) f (a *) -> f (1,2,3)। इसके अतिरिक्त उन्नत पुनरावृत्तियों (जैसे कि सुन्न में ndenumerate) कोड को परिमाण क्लीनर का एक क्रम बनाते हैं।

Comments

ऐसा करने के लिए पायथन सिंटैक्स अच्छा और रसीला लगता है। मुझे आश्चर्य है कि अगर फोरट्रान के साथ ऐसा करने का एक अच्छा तरीका है ...

— मैथ्यू एम्मेट

फोरट्रान में गतिशील स्मृति से निपटने के लिए यह थोड़ा दर्दनाक है। शायद भाषा के साथ मेरी प्रमुख शिकायत है।

— मेवप्लप

Answer 4

$n_1 \times n_2 \times n_3$$n_j=1$

Comments

तो आयाम-स्वतंत्र होने के लिए, आपके कोड को maxdim + 1 आयामों के लिए लिखा जाना चाहिए, जहाँ maxdim अधिकतम संभव आयाम है जिसे उपयोगकर्ता कभी भी सामना कर सकता है। मान लीजिए कि मैक्सिमम = 100। परिणामी कोड कितना उपयोगी है?

— जेफ

Answer 5

यदि आप फोरट्रान की गति को बनाए रखना चाहते हैं तो स्पष्ट उत्तर एक ऐसी भाषा का उपयोग करना है जिसमें जूलिया या सी ++ जैसी उचित कोड पीढ़ी हो। C ++ टेम्प्लेट का उल्लेख पहले ही किया जा चुका है, इसलिए मैं यहां जूलिया के टूल्स का उल्लेख करूंगा। जूलिया के जनरेट किए गए फ़ंक्शन आपको टाइप जानकारी के माध्यम से मांग पर फ़ंक्शन का निर्माण करने के लिए इसके मेटाप्रोग्रामिंग का उपयोग करने देते हैं। तो अनिवार्य रूप से आप यहाँ क्या कर सकते हैं

@generated function f(x)
   N = ndims(x)
   quote
     # build the code for the function
   end
end

और फिर आप Nप्रोग्राम का उपयोग उस कोड को बनाने के लिए करते हैं, जिसे आप यह देखते हुए निष्पादित करना चाहते हैं कि यह Nआयामी है। फिर जूलिया की कार्टेशियन लाइब्रेरी या आइंस्टूम.जेल अभिव्यक्ति जैसे पैकेज को Nआयामी फ़ंक्शन के लिए आसानी से बनाया जा सकता है ।

जूलिया के बारे में यहाँ क्या अच्छा है कि यह फ़ंक्शन संकलित है और आपके द्वारा उपयोग किए जाने वाले प्रत्येक नए आयामी सरणी के लिए अनुकूलित है, इसलिए यह आपको ज़रूरत से ज़्यादा संकलन नहीं करेगा, फिर भी यह आपको सी / फोरट्रान गति प्राप्त करेगा। अंत में यह C ++ टेम्प्लेट का उपयोग करने के समान है, लेकिन यह उच्च स्तरीय भाषा है जिसमें बहुत सारे टूल हैं जो इसे आसान बनाते हैं (इतना आसान है कि यह एक अंडरग्रेजुएट के लिए एक अच्छा होमवर्क समस्या होगी)।

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

Answer 6

मैं उसी (फोरट्रान) नाव में हूं। एक बार जब मेरे पास मेरा 1 डी, 2 डी, 3 डी और 4 डी (मैं प्रोजेक्टिव ज्यामिति करता हूं) तत्व हैं, तो मैं प्रत्येक प्रकार के लिए एक ही ऑपरेटर बनाता हूं और फिर उच्च स्तर के समीकरणों के साथ अपने तर्क लिखता हूं जो यह स्पष्ट करते हैं कि क्या चल रहा है। यह उतना धीमा नहीं है जितना कि आप सोच सकते हैं कि प्रत्येक ऑपरेशन के अलग-अलग छोरों और बहुत सारी मेमोरी कॉपी हैं। मैं संकलक / प्रोसेसर को अनुकूलन करने देता हूं।

उदाहरण के लिए

interface operator (.x.)
    module procedure cross_product_1x2
    module procedure cross_product_2x1
    module procedure cross_product_2x2
    module procedure cross_product_3x3
end interface 

subroutine cross_product_1x2(a,b,c)
    real(dp), intent(in) :: a(1), b(2)
    real(dp), intent(out) :: c(2)

    c = [ -a(1)*b(2), a(1)*b(1) ]
end subroutine

subroutine cross_product_2x1(a,b,c)
    real(dp), intent(in) :: a(2), b(1)
    real(dp), intent(out) :: c(2)

    c = [ a(2)*b(1), -a(1)*b(1) ]
end subroutine

subroutine cross_product_2x2(a,b,c)
    real(dp), intent(in) :: a(2), b(2)
    real(dp), intent(out) :: c(1)

    c = [ a(1)*b(2)-a(2)*b(1) ]
end subroutine

subroutine cross_product_3x3(a,b,c)
    real(dp), intent(in) :: a(3), b(3)
    real(dp), intent(out) :: c(3)

    c = [a(2)*b(3)-a(3)*b(2), a(3)*b(1)-a(1)*b(3), a(1)*b(2)-a(2)*b(1)]
end subroutine

जैसे समीकरणों में उपयोग किया जाना है

m = e .x. (r .x. g)  ! m = e×(r×g)

जहां eऔर rऔर gकिसी भी आयामी स्वरूप है कि बनाता है गणितीय अर्थ हो सकता है।