प्रोग्रामिंग भाषा जे। शौकिया देखो। भाग 4. बक्से और चक्र। निष्कर्ष

प्रोग्रामिंग भाषा में पिछला लेख जे। एक शौकिया की नज़र। भाग 3. सारणी

1. बक्से

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

हालांकि, यह स्पष्ट है कि सरणियों की अपनी सीमाएं हैं। इस तथ्य के कारण कि जे में, डिफ़ॉल्ट रूप से केवल आयताकार सरणियाँ हैं, तथाकथित मानक सरणियों को बनाने का कोई तरीका नहीं है। दांतेदार सरणियाँ। इसके अलावा, सरणियाँ भी असमान तत्वों से मिलकर सूचियों के लिए उपयुक्त नहीं हैं।


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

एक बॉक्स बनाने के लिए, आपको मोनडिक क्रिया को कॉल करने के लिए "<" कॉल करना होगा ("ओपन") बॉक्स से तत्वों को - मोनडिक क्रिया ">":

]x =. <1 2 3 +-----+ |1 2 3| +-----+ 

बॉक्स ASCII ग्राफिक्स में ही तैयार किया गया है। अब हम बॉक्स का मान निकालते हैं:

  >x 1 2 3 

बॉक्स में कई तत्वों को जोड़ने के लिए, क्रिया ";" का उद्देश्य है, जो तत्वों को बॉक्स के अनुक्रम में जोड़ता है:

  1;2;2 +-+-+-+ |1|2|2| +-+-+-+ (i.10) ; 42 ; (i. 2 3) +-------------------+--+-----+ |0 1 2 3 4 5 6 7 8 9|42|0 1 2| | | |3 4 5| +-------------------+--+-----+ 

ऐसे बॉक्सिंग अनुक्रम के तत्वों को सूचीबद्ध करने के लिए, हम भाषण के उन हिस्सों का उपयोग कर सकते हैं जो पहले से ही हमें ज्ञात हैं। उदाहरण के लिए, क्रियाविशेषण "बीच":

  ;/ i.3 +-+-+-+ |0|1|2| +-+-+-+ 

या क्रियाओं की संरचना:

  (#@>)"0 (1 2 3; 2; 3 4) NB.     ( = 0)    3 1 2 

अगला, बॉक्स के दूसरे तत्व को निकालने के लिए क्रिया "{" का उपयोग करें:

  1 { ;/i.3 +-+ |1| +-+ 

इस उदाहरण में, किसी को निम्नलिखित क्षण पर ध्यान देना चाहिए: अनुक्रमणिका कॉल सरणी के बॉक्सिंग तत्व को स्वचालित रूप से अनपैक किए बिना वापस कर देता है।

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

संघ और ऑपरेंड पर दाईं क्रिया को लागू करता है, और परिणाम पर बाईं क्रिया लागू होती है। फिर परिणाम के लिए सही क्रिया के विपरीत क्रिया को लागू किया जाता है। इस प्रकार, हमने वास्तव में ऊपर दिए गए पैराग्राफ में वर्णित एल्गोरिदम को दोहराया। हम बॉक्स के प्रत्येक तत्व को दोगुना करने के लिए इस योजना का उपयोग करते हैं।

  (+: &. >) ;/ i.3 +-+-+-+ |0|2|4| +-+-+-+ 

इस तथ्य के कारण कि अभिव्यक्ति और।> का उपयोग अक्सर किया जाता है, यह डिफ़ॉल्ट रूप से प्रत्येक प्रतीक के साथ जुड़ा हुआ है:

  each &.> (+: each) ;/ i.3 +-+-+-+ |0|2|4| +-+-+-+ 

ध्यान दें कि डेटा प्रोसेसिंग गति में, बॉक्स काफी हैं (परिमाण के 3 आदेश तक!) संख्यात्मक सरणियों के पीछे अंतराल।

2. बहु-पंक्ति क्रियाओं की परिभाषा

"एक सुंदर प्रोग्रामिंग भाषा बनाने में क्या लगता है?"
आइवरसन: "रहस्य वह है जो आप उससे उम्मीद करते हैं।"
फ्रेड ब्रुक्स, ए सेलिब्रेशन ऑफ केनेथ इवरसन, 2004-11-30

क्रिया को मौन रूप में प्रस्तुत करना हमेशा संभव नहीं होता है। इसके लिए, जे में विशेष निर्माण हैं, जिसे हम अनिवार्य कहेंगे। सबसे पहले, ये ऑपरेशन "3:" और "4:" हैं (निरंतर क्रिया "3:" और "4:" के साथ भ्रमित न करें)। डिफ़ॉल्ट ऑपरेंड को "y" कहा जाता है, बाईं ओर "x" है। उदाहरण के लिए:

  v1 =: 3 : '- y' NB.  v2 =: 4 : 'x + y' NB.  

यदि आपको लगता है कि आपकी अनिवार्य परिभाषा को टेस्टिकिटिक रूप में लिखा जा सकता है, लेकिन आप नहीं जानते कि कैसे, तो आप अद्भुत मानक क्रिया रूपांतरण का उपयोग कर सकते हैं:

  13 : 'x + y' + 13 : 'x - (y + 1)' [ - 1 + ] 

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

  v =: 4 : 0 NB.  z =. y + 1 NB.  "z =: ..."     z x - z ) NB.  ,    . 3 4 v 1 2 1 1 

J के पास जाँच स्थितियों (.if), लूप्स (। चालू), और कुछ अन्य के लिए विशेष निर्माण भी हैं। अधिक जानकारी के लिए, हम अनुशंसा करते हैं कि आप दस्तावेज़ से परामर्श करें।

3. पुनरावृत्ति

पुनरावर्ती क्विकॉर्ट फ़ंक्शन को वापस परिचय में दिखाया गया था। आइए एक और उदाहरण देखें। हम पायथन में एक अनुक्रम की लंबाई निर्धारित करने के लिए एक सरल कार्य लिखते हैं जैसे कि कोई ऐसा फ़ंक्शन अंतर्निहित नहीं था।

 def len(xs): """>>> len([1,2,3]) 3""" if xs == []: return 0 return 1+len(xs[1:]) 

जम्मू में एक वेक्टर की लंबाई की गणना के लिए एक पुनरावर्ती कार्य लिखने के लिए, हमें यह निर्धारित करने के लिए एक अतिरिक्त विधेय क्रिया शुरू करनी होगी कि क्या संज्ञा कम से कम एक तत्व के साथ एक अनुक्रम है। इस prateate isa को "सरणी है" वाक्यांश से कॉल करें। हम शुरुआत में इस क्रिया का उपयोग करने का एक उदाहरण लिखेंगे:

  isa 1 NB.  0 isa i.0 NB.  0 isa 1 2 3 NB.  3 

हम यह निर्धारित करेंगे कि क्या ऑपरेंड एक निश्चित स्थिति में वेक्टर से एक तत्व निकालने की क्रिया के माध्यम से 1 से अधिक लंबाई का वेक्टर है। यह क्रिया "{" है

  isa =: ((1: 1&{) :: 0:) : [: 

इस प्रकार, यदि अभिव्यक्ति "1 और {" सही ढंग से पूरी होती है, तो हम मानते हैं कि ऑपरेंड एक सरणी है जिसकी लंबाई 1 से अधिक है। अन्यथा, झूठी (शून्य) लौटें। हमने क्रिया की डाइएडिक कॉल पर परिभाषा में एक प्रतिबंध भी जोड़ा।

किसी कंडीशन की जाँच अनुकरण करने के लिए, हम @ यूनियन का उपयोग करते हैं, जो क्रिया को उस स्थिति में बॉक्स से बाहर कर देता है, जिसे सही ऑपरेंड द्वारा निर्धारित किया जाता है। यानी

  3:`4: @. 1 4: 3:`4: @. 0 3: 

हमें लंबाई = 1 वापस करने की आवश्यकता है यदि सही ऑपरेंड लंबाई = 1 का वेक्टर है, अर्थात। यदि इस संज्ञा पर विधेय isa 0 देता है।

  len =: 1:`(.....) @. isa 

दीर्घवृत्त के स्थान पर, हमें संचरित अनुक्रम की पूंछ के लिए लंबाई की गणना करने के लिए एक पुनरावर्ती कॉल को लागू करना चाहिए। हम इस तथ्य का लाभ उठाते हैं कि जे में पुनरावर्ती कॉल क्रिया "$:" द्वारा लागू किया जाता है। इस प्रकार हमें मिलता है

  len =: 1:`(>:@$:@}.) @. isa len 1 2 3 3 len 17 1 

अगला कदम हमारी क्रिया को फिर से लिखना है ताकि पुनरावर्ती कॉल पूंछ बन जाए। ऐसा करने के लिए, हम बाएं ऑपरेंड में संचित मूल्य को संग्रहीत करेंगे, और क्रिया, इसलिए, रंगादिक हो जाती है:

  len2 =: [`((>:@[) $: (}.@])) @. (isa@]) 1 len2 i.7 7 

एक क्रिया की परिभाषा अप्रभावित दिखती है, और वास्तव में यह है। हम पायथन में एक उदाहरण के साथ क्रिया len2 के एल्गोरिथ्म का वर्णन करते हैं:

 def len2(acc,xs): if xs == []: return acc else: return len2(acc+1, xs[1:]) 

हमारे द्वारा लिखे गए कोड की गति की तुलना करना दिलचस्प है। ऐसा करने के लिए, हम क्रिया "6 !: 2" का उपयोग करते हैं, जो अपने दाहिने ऑपरेंड को कई बार निष्पादित करता है जैसा कि बाएं ऑपेरैंड में इंगित किया गया है और प्रत्येक रन के औसत रन समय को सेकंड में वापस करता है।

  time =: 6!:2 x =: i.1000 10 time 'len x' NB.   0.00614873 10 time '1 len2 x' NB.     0.00553225 10 time '# x' NB.      1.67641e_6 

जैसा कि आप देख सकते हैं, इस मामले में, अंतर्निहित J टूल्स का उपयोग करना हमारे स्वतंत्र कार्यान्वयन की तुलना में तेजी से परिमाण के 3 आदेश हैं। इसके अलावा, जम्मू में पुनरावृत्ति की गहराई पर प्रतिबंध है और पूंछ पुनरावृत्ति का कोई अनुकूलन नहीं है।

यह ध्यान दिया जाना चाहिए कि ऐसी पुनरावर्ती अभिव्यक्तियों के उपयोग की सिफारिश केवल प्रशिक्षण के लिए और आपातकाल के मामले में की जाती है।

4. नाम स्थान

हम जे में प्रोग्रामिंग के लिए वस्तु-उन्मुख दृष्टिकोण के उपयोग पर ध्यान नहीं देंगे। रुचि रखने वालों के लिए, मान लें कि जे में OOP का समर्थन है। और पढ़ें, उदाहरण के लिए, लर्निंग जे में।

ध्यान दें, हालाँकि, J के पास ऐसे नामस्थानों का उपयोग करने के लिए विशेष निर्माण हैं जिनमें OOP टूलकिट के समान सिंटैक्स है।

एक नए नामस्थान की शुरुआत अभिव्यक्ति के साथ होनी चाहिए:

  cocurrent 'name' 

जहां उद्धरण चिह्नों में आपको नाम स्थान का नाम लिखने की आवश्यकता होती है, जो वर्तमान में बन जाता है। डिफ़ॉल्ट नाम स्थान ' base ' है। इसलिए, जैसे ही नाम स्थान में कोड ब्लॉक समाप्त हो गया है, आपको अभिव्यक्ति का उपयोग करके डिफ़ॉल्ट गुंजाइश पर लौटने की आवश्यकता है:

  cocurrent 'base' 

एन्कैप्सुलेटेड नेमस्पेस मेंबर्स तक पहुँचते समय, आपको प्रत्येक तत्व में प्रत्यय _name_ जोड़ना होगा, जहाँ "नाम" नामस्थान है। बड़े नामस्थानों की सिफारिश की जाती है। यहाँ एक अच्छा उदाहरण है:

  cocurrent 'INNER' rate =: 10 v =: 3 : 'rate + y' cocurrent 'base' v_INNER_ 1 11 rate_INNER_ =: 1 v_INNER_ 1 2 

5. उदाहरण

अनुभाग के अंत में, हम एक पाठ्यपुस्तक का उदाहरण देते हैं - त्वरित सॉर्ट क्रिया। J पर Hoar सॉर्ट को इस प्रकार लिखा जा सकता है:

  sel=: 1 : 'x # [' quicksort=: 3 : 0 if. 1 >: #y do. y else. (quicksort y <sel e),(y =sel e),quicksort y >sel e=.y{~?#y end. ) 

आइए रेखा द्वारा परिभाषा रेखा का विश्लेषण करें:

• 1 पंक्ति। आइए पहले हमारे उदाहरण की पहली पंक्ति पर परिभाषित सहायक अभिव्यक्ति sel पर ध्यान दें। पहले, ध्यान दें कि जैसे भाव हैं
  
  

    1 : '' 

  
  
  इंगित करें कि उद्धरण चिह्नों में अभिव्यक्ति एक क्रिया विशेषण है। याद रखें कि एक क्रिया विशेषण से हमारा मतलब एक विशेष निर्माण से है जो क्रिया के व्यवहार को संशोधित करता है, जिसके साथ यह क्रिया विशेषण लागू होता है। इस स्थिति में, क्रिया विशेषण प्रतिलिपि (क्रिया "#") बाएं संकार्य से (क्रिया "[") उन तत्वों को जो "x" में इंगित किए गए हैं।
  
  
• 2 पंक्ति। क्विक-सॉर्ट क्रिया की बहुत परिभाषा 3: 0 के साथ शुरू होती है, जिसका अर्थ है कि इस क्रिया के लिए केवल एक तर्क की अनुमति है।
• 3 लाइन। अगली पंक्ति यह जाँचती है कि यदि 1, ऑपरेंड की लंबाई ("#") से अधिक या बराबर (">") है, तो इस ऑपरेंड का मान लौटाया जाता है, क्योंकि कोई छँटाई की आवश्यकता नहीं है।
• 4-6 लाइन। अन्यथा, क्रिया "," एक सरणी में 3 पुनरावर्ती क्विकॉर्ट कॉल के परिणामों को जोड़ती है। इसके अलावा, पहले वे तत्व हैं जो यादृच्छिक रूप से चयनित तत्व "ई" से छोटे हैं, फिर "ई" के बराबर तत्व हैं, फिर तत्व बड़े "ई" हैं। अभिव्यक्ति के अंत में, मूल्य "ई" परिभाषित किया गया है। इसके अलावा, "{" का अर्थ है एक यादृच्छिक पर एक तत्व की पसंद ("?") खंड 0 पर स्थिति ... ऑपरेंड_लॉग्रेंड ("#y")।
• 7 लाइन। क्रिया की परिभाषा का पूरा होना।

जैसा कि हमने पहले दिखाया, त्वरित छँटाई को एक पंक्ति में लिखा जा सकता है:

  quicksort=: (($:@(<#[) , (=#[) , $:@(>#[)) ({~ ?@#)) ^: (1<#) 

याद है कि "$:" का अर्थ है एक क्रिया की पुनरावर्ती कॉल, और अभिव्यक्ति "@" क्रियाओं की अनुक्रमिक गणना को परिभाषित करती है।

6. टिप्स

लेख लिखने के रहस्य को अच्छी तरह जानना चाहते हैं? 500 लेख लिखें।
रोजर हुई, याद कर केन इवरसन, 2004

• याद रखें कि स्रोत कोड को लिखा जाने की तुलना में अधिक बार पढ़ा जाता है। J के लिए, यह विशेष रूप से सच है।
• क्रियाओं को सार्थक नाम दें। V1, v2 आदि नामों का उपयोग न करें
• एक क्रिया कॉल के उदाहरण के साथ प्रत्येक क्रिया के लिए टिप्पणी लिखना सुनिश्चित करें।
• इकाई परीक्षण लिखना सुनिश्चित करें।
• स्थान और कोष्ठक को टेस्टिकल क्रियाओं में रखें, जहाँ वे वैकल्पिक हों। भाव "+ /: + *: ~ 1:" और "+ /: (+ *: ~ 1 :)" की गणना समान हैं, लेकिन उत्तरार्द्ध पढ़ना आसान है।

यहां यह ध्यान दिया जाना चाहिए कि जे में गुरु प्रोग्रामर का कोड अक्सर उपरोक्त सभी सिफारिशों का उल्लंघन करता है।

• ध्यान रखें कि एक क्रिया को उस तरीके से नहीं बुलाया जा सकता है जैसा आपने इसे किया था: इसमें एक मोनाड और डियाड कॉल दोनों शामिल हैं। जे के त्रुटि संदेश बहुत जानकारीपूर्ण नहीं हैं।
• कॉम्पैक्ट क्रिया परिभाषाएं बनाएं। 20 वर्णों की लंबाई वाले दो क्रिया प्रत्येक को 40 वर्णों की लंबाई के साथ एक क्रिया से पढ़ना आसान है।
• यदि एक क्रिया "पुस्तक" गणितीय सूत्र की गणना करती है, तो इसे केवल टैटिट रूप में लिखें यदि यह गणना की दक्षता में काफी वृद्धि करता है। अन्य मामलों में, स्पष्ट ऑपरेंड के साथ लिखें।
• आवश्यक होने पर ही चक्रीय अनिवार्य और पुनरावर्ती निर्माण का उपयोग करें। यद्यपि वे कभी-कभी किसी कार्यक्रम को पढ़ना आसान बनाते हैं, वे बहुत धीमी गति से होते हैं। क्रियाविशेषण "/", "\" और इसी तरह का उपयोग करें।
• ओओपी मॉड्यूल के रूप में सभी फाइलों को परिभाषित करने पर विचार करें।
• यदि संभव हो, तो वैश्विक चर का उपयोग न करें।
• पुस्तक "जे फॉर सी प्रोग्रामर्स" पढ़ें। "लूपलेस कोड" शीर्षक वाले अध्यायों पर विशेष ध्यान दें।

7. आगे क्या पढ़ना है

जो हो रहा है उसका एक से अधिक स्पष्टीकरण कभी न दें - उत्तरार्द्ध हमेशा सही होगा
केनेथ इवरसन।

• http://vector.org.uk ब्रिटिश एसोसिएशन ऑफ एपीएल प्रोफेशनल्स की एक बहुत ही प्रतिष्ठित पत्रिका है। लेख मुख्य रूप से एपीएल भाषा के बारे में हैं, लेकिन भाषाओं पर कई लेख हैं जे, क्यू, के। सब कुछ इलेक्ट्रॉनिक रूप से डाउनलोड किया जा सकता है। अत्यधिक की सिफारिश की।
• http://nsl.com - साइट का नाम "नो स्टिंकिंग लूप्स" है। साइट में जटिलता की डिग्री बदलती के कई उदाहरण हैं। ज्यादातर के। में, उदाहरण के लिए, K में K के एक आलसी उपसमुच्चय का कार्यान्वयन है।
• http://www.jsoftware.com/jwiki/Links - जे। भाषा में उपयोगी संसाधनों के लिंक का एक संग्रह
• http://jsoftware.com/forums.htm - जे मेलिंग सूची (गतिविधि बहुत अधिक है - उदाहरण के लिए, मुख्य प्रोग्रामिंग अनुभाग में, प्रति दिन औसतन 8-12 संदेश)।
• http://www.jsoftware.com/jwiki/Essays - इस "ज्ञान के अटूट स्रोत" के बारे में मत भूलना - लेखों और टिप्पणियों के साथ उदाहरणों का एक संग्रह। उदाहरणों में, आप 30 पंक्तियों में एक सुडोकू सॉल्वर पा सकते हैं।

एक निष्कर्ष के बजाय

मैंने एक बार केन से कहा था, "आप जानते हैं, केन, आप प्रोग्रामिंग भाषाओं के मेरे पसंदीदा डिजाइनर हैं, और डॉन नुट मेरे पसंदीदा प्रोग्रामर हैं।" केन ने तुरंत पूछा: "मेरी प्रोग्रामिंग में क्या गलत है?"
- जॉय टटल, ए सेलिब्रेशन ऑफ केनेथ इवरसन, 2004-11-30