मैं योजना के लिए तथ्यात्मक कितने तरीके लिख सकता हूं?

दुष्ट भाषाओं का दावा है कि कार्यात्मक प्रोग्रामिंग भाषाएं "तथ्यात्मक लेखन भाषाएँ" हैं। यह सबसे अधिक बार हास्केल भाषा के रूप में परिभाषित किया जाता है, लेकिन हम कार्यात्मक भाषा के साथ शुरू करेंगे जिसने हास्केल और कई अन्य भाषाओं के लिए कार्यात्मक प्रोग्रामिंग टूल के सबसेट को प्रभावित किया - योजना। कम से कम map और for-each , filter और reduce , साथ ही apply और eval हमारी पसंदीदा प्रोग्रामिंग भाषाओं में आए, यदि स्कीम से नहीं, तो वहां से।

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

मुझे फ़ंक्शन परिभाषाएँ लिखने के लिए 10 विकल्प मिले, जिन्हें गणना के 3 मुख्य तरीकों से कम किया जा सकता है: पारंपरिक रैखिक पुनरावर्ती कम्प्यूटेशनल प्रक्रिया, पुनरावृत्ति, संख्याओं के अनुक्रम की पीढ़ी, इसके बाद कन्वेंशन गुणन। मैं इन विकल्पों पर अधिक विस्तार से विचार करने का प्रस्ताव करता हूं। रास्ते के साथ, हम विचार करेंगे: पूंछ पुनरावृत्ति अनुकूलन, उच्च-क्रम के कार्य और मेटाप्रोग्रामिंग, आस्थगित गणना, अंतहीन सूचियां, संस्मरण, योजना में एक स्थिर चर बनाने का एक तरीका, और स्वच्छता मैक्रोज़।

प्रयोगों के लिए, हमने अच्छी पुरानी बोली योजना R5RS और ललित कला के लोकप्रिय सिद्धांत "न्यूनतम साधन - अधिकतम इंप्रेशन" का उपयोग किया।

सभी योजना उदाहरण R5RS मोड में DrRacket 6.2 में तैयार किए गए थे। OpenSUSE लीप 15 OS वातावरण में गुइल 2.0 में रनटाइम माप किए गए थे।

आरंभ करने के लिए, आप भाज्य की पुनरावर्ती परिभाषा ले सकते हैं और योजना पर सूत्र को फिर से लिख सकते हैं:

 (define (factorial-classic n) (if (zero? n) 1 (* n (factorial-classic (- n 1))))) 

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

आप इस कोड को इस तरह से पढ़ और समझ सकते हैं: भाज्य $$$एन$ वहाँ है $$$1$ अगर $$$n = 0$ अन्यथा - $$$n \ cdot (n-1)!$ । इस प्रकार, यह कोड गुटबाजी की पुनरावर्ती परिभाषा से मेल खाता है, जिसे गणित में अपनाया गया है। केवल एक चीज हम संबद्धता की जांच नहीं करते हैं $$$एन$ गैर-नकारात्मक संख्या।

पुनरावर्ती होने के कारण, ऊपर दिए गए कोड में मूल्य पर एक स्पष्ट प्रतिबंध है $$$एन$ : पुनरावर्ती कॉल डेटा तब तक स्टैक पर जमा होगा $$$एन$ 0. तक नहीं पहुंचेगा। इससे बड़े स्तर पर स्टैक ओवरफ्लो हो सकता है $$$एन$ ।

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

यदि आप उपरोक्त पुस्तक के लेखकों की सिफारिशों का उपयोग करते हैं, तो आप निम्नलिखित प्राप्त कर सकते हैं:

 (define (factorial-classic-tco n) (define (iteration product counter) (if (> counter n) product (iteration (* product counter) (+ counter 1)))) (iteration 1 1)) 

यह कोड एक सामान्य उदाहरण है, और "कंप्यूटर प्रोग्राम की संरचना और व्याख्या" पुस्तक के साथ शुरू होता है, यह इस पर है कि पूंछ पुनरावृत्ति का अनुकूलन आमतौर पर समझाया जाता है।

यह एक क्लासिक था। लेकिन योजना अपने आप में लचीलापन है, क्या एक ही चीज़ को मौलिक रूप से अलग तरीके से लिखना संभव है? और अधिमानतः कम भी? उदाहरण के लिए, प्रविष्टि के अनुसार $$$n! = 1 \ cdot 2 \ cdot 3 \ cdot ~ \ cdots ~ \ cdot n$ से एक क्रम बनाएँ $$$1$ को $$$एन$ (या से $$$एन$ को $$$1$ ) और फिर इसे गुणा करके घटाएं? सौभाग्य से, इस योजना में बिल्ट-इन apply प्रक्रिया के लिए यह काफी सरल है, जो सूची में मनमानी संख्या के साथ एक प्रक्रिया लागू करती है:

 (define (iota n) (define (iteration sequence i) (if (> in) sequence (iteration (cons i sequence) (+ i 1)))) (iteration '() 1)) (define (factorial-fold n) (apply * (iota n))) 

योजना "कोड और डेटा की एकता" के कारण प्रतीकात्मक गणना के लिए अपनी सुविधा के लिए प्रसिद्ध है (जैसा कि वे कभी-कभी लिस्प परिवार की भाषाओं के बारे में कहते हैं)। हम इस सुविधा का उपयोग करते हैं: हम एक संख्या के भाज्य की गणना के लिए एक अभिव्यक्ति बनाते हैं $$$एन$ और फिर इसकी गणना करें:

 (define (factorial-eval n) (define expression `(* ,@(iota n))) (eval expression (interaction-environment))) 

प्रतीक "बैक सिंगल उद्धरण" का अर्थ है क्वासिकोटेशन। अर्ध-उद्धरण के बिना, कोड का उपयोग करके आगे की गणना के लिए एक अभिव्यक्ति प्राप्त की जा सकती है (cons '* (iota n)) । एक एकल उद्धरण (उद्धरण, उद्धरण) का मतलब है कि * अभिव्यक्ति में बिल्कुल एक नाम (प्रतीक) के रूप में प्रतिस्थापित किया जाना चाहिए, और इसी मूल्य (यहां - प्रक्रिया) के रूप में नहीं। तो, के साथ $$$n = 3$ हमें मिलता है (* 3 2 1) । यह सूची योजना की एक अभिव्यक्ति है। इसका मूल्य एक उपयुक्त वातावरण में, सबसे अच्छा - एक पर्यावरण (interaction-environment) में निर्मित प्रक्रियाओं और कार्यक्रम में हमारे द्वारा परिभाषित प्रक्रियाओं से युक्त में किया जा सकता है। वास्तव में, यह वही है जो हम factorial-eval के शरीर में करते हैं।

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

 ghci> take 4 [1 ..] [1,2,3,4] 

अभिव्यक्ति [1 ..] पूर्णांक की एक अनंत सूची उत्पन्न करता है। take 4 एक्सप्रेशन को इस सूची से पहले 4 तत्व मिलते हैं। चूंकि बाद की सूची आइटम लावारिस बने हुए हैं, उनकी गणना नहीं की जाती है।

हास्केल में हो रही है $$$एन!$ एक अंतहीन सूची से आप इस तरह लिख सकते हैं:

 factorials :: [Integer] factorials = next 0 1 where next n fact = let n' = n + 1 in fact : next n' (fact * n') factorial :: Integer -> Integer factorial n = factorials !! fromIntegral n 

 ghci> take 7 $ factorials [1,1,2,6,24,120,720] ghci> factorial 6 720 

योजना delay / force कुछ रूपों का उपयोग करते हुए force आइए कुछ ऐसा ही करने का प्रयास करें। delay कीवर्ड एक अभिव्यक्ति के मूल्य का मूल्यांकन करने का वादा करता है। force कीवर्ड इन गणनाओं को करने का निर्देश देता है, जिसके परिणामस्वरूप मूल्य की गणना और संग्रहित किया जाता है। बार-बार पहुंचने पर, नई गणना नहीं की जाती है, लेकिन पहले की गणना की गई राशि वापस आ जाती है।

लिस्प परिवार की भाषाओं में, जोड़े से सूचियों का निर्माण किया जाता है। अनंत सूचियों का निर्माण करने के लिए, हम "आलसी जोड़ी" के प्रकार का परिचय देते हैं - एक जोड़ी जिसमें पहला तत्व गणना मूल्य है, और दूसरा मूल्य की गणना करने का वादा है। ऐसा करने के लिए, हमें लिस्प परिवार ( cons , car , cdr ) की भाषाओं के "पवित्र त्रिमूर्ति" को उनके आलसी संस्करणों के साथ पूरक करने की आवश्यकता है:

 (define-syntax lazy-cons (syntax-rules () ((_ first second) (cons first (delay second))))) (define lazy-car car) (define (lazy-cdr lazy-pair) (force (cdr lazy-pair))) 

lazy-cons जोड़ी के निर्माण को मैक्रो के रूप में लागू किया जाता है। यह जोड़े के दूसरे तत्व के मूल्य की गणना करने से बचने के लिए किया जाता है जब इसे बनाया जाता है।

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

 (define (lazy-list-ref lazy-list index) (if (zero? index) (lazy-car lazy-list) (lazy-list-ref (lazy-cdr lazy-list) (- index 1)))) (define (generate-factorials) (define (next nn!) (define n+1 (+ n 1)) (lazy-cons n! (next n+1 (* n! n+1)))) (next 0 1)) 

यहाँ n! और n+1 चर के नाम हैं। अन्य भाषाओं की तुलना में स्कीम में, बहुत कम अक्षर हैं जिनका उपयोग पहचानकर्ताओं में नहीं किया जा सकता है।

ध्यान दें कि अनंत सूची जेनरेटर generate-factorials में पुनरावृत्ति का कोई रास्ता नहीं होता है। हालांकि, इसे लूप नहीं किया जाएगा, क्योंकि जब इसे बुलाया जाता है, तो केवल सूची के प्रमुख की गणना की जाएगी, जबकि पूंछ को मूल्य की गणना करने के वादे से दर्शाया जाएगा।

अब आप परिभाषित कर सकते हैं $$$एन!$ कैसे प्राप्त करें $$$एन$ गुटों की सूची का तत्व:

 (define lazy-factorials (generate-factorials)) (define (factorial-lazy n) (lazy-list-ref lazy-factorials n)) 

यह काम करता है। इसके अलावा, यदि इंटरप्रेटर के एक सत्र में विभिन्न संख्याओं के भाज्य की गणना की जाती है, तो सख्त संस्करणों की तुलना में गणना तेजी से होगी, क्योंकि आलसी सूची के कुछ मूल्यों की गणना पहले से ही की जाएगी।

वैसे, स्कीम पर कोड हास्केल पर बहुत करीब है। तो, प्राप्त बयान !! लगभग lazy-list-ref प्रक्रिया से मेल खाती है lazy-list-ref निर्माणकर्ता : lazy-cons मेल खाती है। इसके विपरीत, क्योंकि हास्केल, हालांकि यह एक आलसी गणना मॉडल को स्वीकार करता है, हालांकि, योजना में delay / force विपरीत, यह गणना किए गए मूल्यों को याद नहीं करता है।

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

 (define factorial-memoized (let ((memo '())) (lambda (n) (let ((memoized (assq n memo))) (if memoized (cadr memoized) (if (zero? n) 1 (let ((computed (* n (factorial-memoized (- n 1))))) (set! memo (cons (list n computed) memo)) computed))))))) 

 (define proc (let ((static-var initial-value)) (lambda args ...))) 

 (define count (let ((n 0)) (lambda () (set! n (+ n 1)) n))) 

 (define count ((lambda (n) (lambda () (set! n (+ n 1)) n)) 0)) 

यह कार्यान्वयन एक दुभाषिया सत्र में विभिन्न संख्याओं के भाज्य की बार-बार गणना करके प्रदर्शन लाभ का वादा करता है।

बेशक, पूंछ पुनरावृत्ति अनुकूलन भी यहां संभव है:

 (define factorial-memoized-tco (let ((memo '())) (lambda (n) (define (iteration product counter) (cond ((> counter n) product) (else (set! memo (cons (list counter product) memo)) (iteration (* product counter) (+ counter 1))))) (iteration 1 1)))) 

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

 (define (factorial-do n) (define product 1) (do ((i 1 (+ i 1))) ((> in) product) (set! product (* product i)))) 

do निर्माण काफी बहुमुखी है, और यही कारण है कि यह बहुत पठनीय नहीं है। क्या अपनी खुद की अनिवार्य शैली चक्र को व्यवस्थित करना बेहतर नहीं है? मैक्रों इसकी मदद करेंगे:

 (define-syntax for (syntax-rules () ((_ (variable init test step) . body) (let loop ((variable init)) (if test (begin (begin . body) (loop step))))))) 

दुभाषिया द्वारा पूंछ पुनरावृत्ति के अनुकूलन के लिए धन्यवाद, हमें एक लूप मिलता है जिसका उपयोग हम अनिवार्य प्रोग्रामिंग भाषाओं में करते हैं। पूंछ की पुनरावृत्ति का अनुकूलन करके, ढेर नहीं बढ़ेगा।

के for उपयोग कर फैक्टरिंग परिभाषित करना:

 (define (factorial-for n) (define product 1) (for (i 1 (<= in) (+ i 1)) (set! product (* product i))) product) 

 for → _ i → variable 1 → init (<= in) → test (+ i 1) → step (set! product (* product i)) → body 

 (define (factorial-for n) (define product 1) (let loop ((i 1)) ;   (if (<= in) ;  (begin (begin (set! product (* product i))) ;  (loop (+ i 1))))) ;  for product) 

एक और विकल्प है जो लूप के for अनिवार्य के समान दिखता है - अंतर्निहित for-each प्रक्रिया के साथ:

 (define (factorial-for-each n) (define product 1) (for-each (lambda (i) (set! product (* product i))) (iota n)) product) 

महान और शक्तिशाली योजना भाषा! प्रदर्शन के बारे में क्या?

हम प्रदर्शन को मापने के लिए GNU Guile का उपयोग करेंगे - इस माहौल में आप किसी अभिव्यक्ति का मूल्यांकन करने में लगने वाले समय को माप सकते हैं।

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

हम एक निश्चित मूल्य पर माप लेंगे $$$एन$ । यह क्या होना चाहिए $$$एन$ ? तो जिसके साथ सबसे महान है $$$एन$ प्रस्तावित विकल्पों के साथ "सामना" करने में सक्षम होगा। डिफ़ॉल्ट गइल 2.0 सेटिंग्स के साथ, इंटेल कोर i5 और 4 जीबी रैम के साथ पीसी पर, मुझे निम्नलिखित मिला:

यहां से, प्रदर्शन परीक्षण प्रदर्शन किया गया $$$n = 8 \, 000$ । परिणाम नीचे दी गई तालिका में प्रस्तुत किए गए हैं, जहां $$$t_ {रन}$ - लीड समय $$$t_ {GC}$ - कचरा कलेक्टर सेकंड में समय चलाते हैं।
आलसी और ज्ञापन को छोड़कर सभी प्रक्रियाओं के लिए, रनटाइम के सबसे छोटे मूल्य और कचरा कलेक्टर के संगत समय प्राप्त होते हैं, तीन प्रारंभ के परिणामों से प्राप्त होते हैं। $$$n = 8 \, 000$ ।
ज्ञापन और आलसी प्रक्रियाओं के लिए, पहली कॉल का निष्पादन समय इंगित किया जाता है, फिर तीन कॉल के छोटे।

हमारे पास 4 विकल्प हैं जो बड़े काम कर सकते हैं $$$एन$ । पर $$$n = 100 \, 000$ उनके पास निम्नलिखित गणना और कचरा संग्रहण समय है:

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

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