पर्ल पुनरावृत्ति गणना

हैलो,
इस पोस्ट में मैं आपको पर्ल में कार्यक्षमता जोड़ने के लिए नुस्खा बताऊंगा।

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

 f (0) = 1
 f (n) = n * f (n-1)

कार्यात्मक प्रोग्रामिंग भाषाएं इस तरह के कार्यों को परिभाषित करना आसान बनाती हैं, एरलंग में, यह निम्नानुसार किया जाता है:

  भाज्य (को ०) ->
     1;
 भाज्य (एन) ->
     एन * फैक्टोरियल (एन -1)। 

अब कुछ ऐसा ही करने की कोशिश करते हैं, जो हमें फ़ॉर्म का कोड लिखने की अनुमति देगा:

#! / usr / bin / perl -I./lib
सख्त का उपयोग करें ;
bigint का उपयोग करें ;

आवर्तक का उपयोग करें ;

आवर्तक पहलू => {
arg ( 0 ) => लैम्ब्डा { my ( $ n ) = @_ ; वापसी 1 } ,
arg ( n ) => लंबा { my ( $ n ) = @_ ; वापसी $ n * fac ( $ n - 1 ) } ,
} ;

प्रिंट फेस ( 100 ) ;

जैसा कि आप उदाहरण से देख सकते हैं, हमारे पास नए कार्य हैं आवर्तक, arg, n और lambda। वास्तव में, केवल आवर्तक के व्यावहारिक लाभ हैं, बाकी सभी को केवल "सुंदर" कोड प्राप्त करने के लिए आवश्यक है।

चलिए मॉड्यूल को लिखता हूं Recurrent.pm

 पैकेज आवर्तक;
 हमारे $ संस्करण = '0.01';
 आधार qw (निर्यातक) का उपयोग करें;

 सख्त का उपयोग करें;
 कार्प qw (कबूल) का उपयोग करें;

 हमारे @EXPORT = qw (arg n lambda आवर्तक);

 सब आर्ग {शिफ्ट} # पहला तर्क देता है
 उप n {''} # एक रिक्त स्ट्रिंग देता है
 उप लंबा (&) {शिफ्ट} # उप नाम के लिए उप {}
 उप आवर्तक ($ $) { 
     my ($ नाम, $ मैपिंग) = @_;
     कबूल '$ नाम एक स्ट्रिंग होना चाहिए'
         अगर रेफरी ($ नाम) ne '' ||  $ नाम! ~ / ^ \ p {XID_Start} \ p {XID_Continue} * $ /;
     कबूल करना '$ मैपिंग एक हैश संदर्भ होना चाहिए'
         अगर रेफरी ($ मैपिंग) ने 'एचएएसएच';
     कबूल नहीं 'समवर्ती संबंध में कोई पैरामीट्रिक फ़ंक्शन'
         अगर रेफरी ($ मैपिंग -> {(n ())}) ने 'CODE';
     {
         कोई सख्त 'रेफ्स' नहीं;
        
         # एक कैश और $ नाम फ़ंक्शन बनाएँ
         मेरे $ मेम = ज्वाइन ('::', (कॉलर ()) [0], "RECURRENT_CACHE_ $ नाम");
         मेरा $ मज़ा = जुड़ना ('::', (कॉलर ()) [0], "$ नाम");
        
         {{$ मेम} = = {};
         {{$ मजा} = उप {
             my ($ _ n, $ _mapping) = ($ # _; $ _ [1]: $ _ [0], $ टैपिंग);
            
             कबूल करना "तर्क $ नाम (n) के लिए आवश्यक है"
                 अगर; परिभाषित $ _n;
                
             # कैश में मूल्य देखें, यदि नहीं, तो गणना करें
             परिभाषित ($ {* {$ मेम}} -> {$ _ n})
                 ?  ($ {* {$ मेम}} -> {$ _ n})
                 : ($ {* {$ मेम}} -> {$ _ n} =
                     परिभाषित ($ _ मानचित्रण -> {$ _ n})
                         ?  do {स्थानीय $ _ = $ _n;  $ _mapping -> {$ _ n} -> ($ _ n)}
                         : do {स्थानीय $ _ = $ _n;  $ _mapping -> {(n)} -> ($ _ n)});
         };
     }
 }

 1;

अब, आप कुछ ऐसा लिख ​​सकते हैं।

#! / usr / bin / perl -I./lib
सख्त का उपयोग करें ;
bigint का उपयोग करें ;

आवर्तक का उपयोग करें ;

# # f (0) = 0
# # f (1) = 1
# # f (n) = f (n-1) + f (n-2)
आवर्तक तंतु => {
arg ( 0 ) => लैम्ब्डा { my ( $ n ) = @_ ; वापसी 0 } ,
arg ( 1 ) => लैम्ब्डा { my ( $ n ) = @_ ; वापसी 1 } ,
arg ( n ) => लंबा { my ( $ n ) = @_ ; रिटर्न फ़ाइब ( $ n - 1 ) + फ़ाइब ( $ n - 2 ) } ,
} ;

प्रिंट फ़ाइब ( 100 ) ;

एक बोनस के रूप में, हम एक बाएं हाथ के कनवल्शन को कम या मोड़ के रूप में जानते हैं

उप घटा ( & @ ) {
my ( $ f , $ z , @x ) = @_ ;
नक्शा {
स्थानीय ( $ a , $ b ) = ( $ _ , $ z ) ;
$ z = $ f -> ( $ a , $ b ) ;
} @x ;
$ z ;
}

और 1 से 100 तक फाइबोनैचि संख्याओं के योग की गणना करें

 प्रिंट कम {$ a + $ b} नक्शा {fib ($ _)} 1..100;

अपडेट:
आशुलिपि वाक्यविन्यास समर्थन

#! / usr / bin / perl -I./lib
utf8 का उपयोग करें ;

सख्त का उपयोग करें ;
bigint का उपयोग करें ;

आवर्तक का उपयोग करें ;

उप λ ( & ) { शिफ्ट }
# # = (0) = 0
# # = (1) = 1
# # = (n) = ƒ (n-1) + n (n-2)
आवर्तक ƒ => {
( 0 ) => λ { 0 } ,
( 1 ) => λ { 1 } ,
( n ) => λ { ƒ ( $ _ - 1 ) + $ ( $ _ - 2 ) } ,
} ;

प्रिंट print ( 100 ) ;