प्योर (प्रोग्रामिंग लैंग्वेज): Difference between revisions

From Vigyanwiki
(text)
Line 49: Line 49:
                 = i1==i2 || j1==j2 || i1+j1==i2+j2 || i1-j1==i2-j2;
                 = i1==i2 || j1==j2 || i1+j1==i2+j2 || i1-j1==i2-j2;
  end;
  end;
जबकि शुद्ध डिफ़ॉल्ट रूप से [[उत्सुक मूल्यांकन]] का उपयोग करता है, यह [[आलसी मूल्यांकन]] डेटा संरचनाओं जैसे धाराओं (आलसी [[सूची (कंप्यूटिंग)]]) का भी समर्थन करता है। उदाहरण के लिए, [[डेविड टर्नर (कंप्यूटर वैज्ञानिक)]] का एल्गोरिदम<ref>Turner, David A. SASL language manual. Tech. rept. CS/75/1. Department of Computational Science, University of St. Andrews 1975.</ref> [[परीक्षण प्रभाग]] द्वारा अभाज्य संख्याओं की धारा की गणना के लिए शुद्ध में व्यक्त किया जा सकता है:
जबकि शुद्ध डिफ़ॉल्ट रूप से [[उत्सुक मूल्यांकन]] का उपयोग करता है, यह [[आलसी मूल्यांकन|लज़ी मूल्यांकन]] डेटा संरचनाओं जैसे धाराओं (लज़ी [[सूची (कंप्यूटिंग)]]) का भी समर्थन करता है। उदाहरण के लिए, [[डेविड टर्नर (कंप्यूटर वैज्ञानिक)]] का कलन विधि<ref>Turner, David A. SASL language manual. Tech. rept. CS/75/1. Department of Computational Science, University of St. Andrews 1975.</ref> [[परीक्षण प्रभाग]] द्वारा अभाज्य संख्याओं की धारा की गणना के लिए शुद्ध में व्यक्त किया जा सकता है:
  primes = sieve (2..inf) with


<वाक्यविन्यास प्रकाश लैंग = Q>
  sieve (p:qs) = : sieve [q | q = qs; q mod p] &;
primes = छलनी (2..inf) के साथ
end;
  छलनी (p:qs) = p : छलनी [q | क्ष = क्ष; Q मॉड पी] &;
<code>&</code> का उपयोग ऑपरेटर को इसकी गणना में देरी करने के लिए [[थंक]] में बदल देता है। जब सूची के संबंधित भाग तक पहुँचा जाता है, तो थंक का मूल्यांकन निहित रूप से किया जाता है और फिर [[संस्मरण]] (आवश्यक मूल्यांकन द्वारा कॉल का उपयोग करके) किया जाता है, उदाहरण के लिए:
अंत;
primes!!(0..99); // yields the first 100 primes
</वाक्यविन्यास हाइलाइट>
शुद्ध में वेक्टर और मैट्रिक्स कॉम्प्रिहेंशन सहित वेक्टर और मैट्रिसेस ([[MATLAB|एमएटीएलएबी]] और जीएनयू ऑक्टेव के समान) के लिए कुशल समर्थन है। उदाहरण के लिए, आंशिक पिवोटिंग के साथ [[गाउस विलोपन]] कलन विधि को शुद्ध में लागू किया जा सकता है:
gauss_elimination x::matrix = p,x when n,m = dim x; p,_,x = foldl step (0..n-1,0,x) (0..m-1) end;


का उपयोग <code>&</code> ऑपरेटर छलनी की पूंछ को इसकी गणना में देरी करने के लिए एक [[थंक]] में बदल देता है। जब सूची के संबंधित भाग तक पहुँचा जाता है, तो थंक का मूल्यांकन निहित रूप से किया जाता है और फिर [[संस्मरण]] (आवश्यक मूल्यांकन द्वारा कॉल का उपयोग करके) किया जाता है, उदाहरण के लिए:
step (p,i,x) j = if max_x==0 then p,i,x else


<वाक्यविन्यास प्रकाश लैंग = Q>
    // updated row permutation and index:
primes!!(0..99); // पहले 100 अभाज्य संख्याएँ प्राप्त करता है
    transp i max_i p, i+1,
</वाक्यविन्यास हाइलाइट>
     {// the top rows of the matrix remain unchanged:
 
शुद्ध में वेक्टर और मैट्रिक्स कॉम्प्रिहेंशन सहित वेक्टर और मैट्रिसेस ([[MATLAB]] और GNU ऑक्टेव के समान) के लिए कुशल समर्थन है। उदाहरण के लिए, आंशिक पिवोटिंग के साथ एक [[गाउस विलोपन]] एल्गोरिथम को शुद्ध में लागू किया जा सकता है:
 
<वाक्यविन्यास प्रकाश लैंग = Q>
गॉस_एलिमिनेशन एक्स :: मैट्रिक्स = पी, एक्स
जब एन, एम = मंद एक्स; p,_,x = तह चरण (0..n-1,0,x) (0..m-1) अंत;
 
चरण (पी, आई, एक्स) जे
= अगर max_x==0 तो p,i,x और
    // अद्यतन पंक्ति क्रमपरिवर्तन और अनुक्रमणिका:
    ट्रांसप आई मैक्स_आई पी, आई+1,
     {// मैट्रिक्स की शीर्ष पंक्तियां अपरिवर्तित रहती हैं:
     x!!(0..i-1,0..m-1);
     x!!(0..i-1,0..m-1);
     // धुरी पंक्ति, धुरी तत्व से विभाजित:
     // the pivot row, divided by the pivot element:
     {x!(i,l)/x!(i,j) | एल=0..एम-1};
     {x!(i,l)/x!(i,j)                 | l=0..m-1};
     // धुरी पंक्ति के उपयुक्त गुणकों को घटाएं:    
     // subtract suitable multiples of the pivot row:
{{x!(k,l)-x!(k,j)*x!(i,l)/x!(i,j) | k=i+1..n-1; l=0..m-1}}
    {{x!(k,l)-x!(k,j)*x!(i,l)/x!(i,j) | k=i+1..n-1; l=0..m-1}}
कब
  एन, एम = मंद एक्स; max_i, max_x = धुरी i (कर्नल एक्स जे);
  x = if max_x>0 तो x i max_i और x स्वैप करें;
के साथ समाप्त करना
  पिवोट आई एक्स = फोल्डल मैक्स (0,0) [जे, एब्स (एक्स! जे) | जे = आई .. # एक्स -1];
  अधिकतम (i,x) (j,y) = यदि x<y तो j,y और i,x;
अंत;


/* मैट्रिक्स x की पंक्तियों i और j को स्वैप करें। */
when


स्वैप x i j = x !! (transp i j (0..n-1), 0..m-1) जब n, m = मंद x अंत;
  n,m = dim x; max_i, max_x = pivot i (col x j);
  x = if max_x>0 then swap x i max_i else x;


/* क्रमचय पर स्थानान्तरण लागू करें। */
end with


ट्रांसप आई जे पी = [पी! टीआर के | के=0..#पी-1]
  pivot i x = foldl max (0,0) [j,abs (x!j)|j=i..#x-1];
टीआर के साथ = अगर के == मैं तो जे और अगर के == जे तो मैं और के अंत;
  max (i,x) (j,y) = if x<y then j,y else i,x;


/* उदाहरण: */
end;


मान लीजिए x = dmatrix {2,1,-1,8; -3,-1,2,-11; -2,1,2,-3};
/* Swap rows i and j of the matrix x. */
एक्स; गॉस_एलिमिनेशन एक्स;
</वाक्यविन्यास हाइलाइट>


शब्द पुनर्लेखन पर आधारित भाषा के रूप में, शुद्ध अभिव्यक्ति के साथ प्रतीकात्मक संगणना का पूरी तरह से समर्थन करता है। यहाँ एक उदाहरण है जो [[बहुपद विस्तार]] और [[गुणन]]खंड सरल अंकगणितीय अभिव्यक्तियों के लिए स्थानीय पुनर्लेखन नियमों का उपयोग दिखा रहा है:
swap x i j = x!!(transp i j (0..n-1),0..m-1) when n,m = dim x end;


<वाक्यविन्यास प्रकाश लैंग = Q>
/* Apply a transposition to a permutation. */
विस्तार = के साथ कम करें
  (ए+बी)*C = ए*C+बी*C;
  ए * (बी + C) = ए * बी + ए * C;
अंत;


कारक = के साथ कम करें
transp i j p = [p!tr k | k=0..#p-1] with tr k = if k==i then j else if k==j then i else k end;
  ए * C + बी * C = (ए + बी) * C;
  ए * बी + ए * C = ए * (बी + C);
अंत;


विस्तार ((ए + बी) * 2); // पैदावार ए * 2 + बी * 2
/* Example: */
कारक (ए * 2 + बी * 2); // पैदावार (ए + बी) * 2
</वाक्यविन्यास हाइलाइट>


Pure से C (प्रोग्रामिंग लैंग्वेज) फंक्शन को कॉल करना बहुत आसान है। उदाहरण के लिए, निम्नलिखित आयात करता है <code>puts</code> [[सी पुस्तकालय|C लाइब्रेरी]] से कार्य करता है और स्ट्रिंग को प्रिंट करने के लिए इसका उपयोग करता है <code>"Hello, world!"</code> टर्मिनल पर:
let x = dmatrix {2,1,-1,8; -3,-1,2,-11; -2,1,2,-3}; x; gauss_elimination x;
 
शब्द पुनर्लेखन पर आधारित भाषा के रूप में, शुद्ध अभिव्यक्ति के साथ प्रतीकात्मक संगणना का पूरी तरह से समर्थन करता है। यहाँ एक उदाहरण है जो [[बहुपद विस्तार]] और [[गुणन]]खंड सरल अंकगणितीय अभिव्यक्तियों के लिए स्थानीय पुनर्लेखन नियमों का उपयोग दिखा रहा है:
<वाक्यविन्यास प्रकाश लैंग = C>
expand = reduce with
बाहरी इंट पुट (चार *);
  (a+b)*c = a*c+b*c;
हैलो = हैलो, दुनिया डालता है! ;
  a*(b+c) = a*b+a*c;
नमस्ते;
end;
</वाक्यविन्यास हाइलाइट>
factor = reduce with
  a*c+b*c = (a+b)*c;
  a*b+a*c = a*(b+c);
end;
expand ((a+b)*2); // yields a*2+b*2
factor (a*2+b*2); // yields (a+b)*2
शुद्ध (प्रोग्रामिंग भाषा) से C (प्रोग्रामिंग लैंग्वेज) फंक्शन को कॉल करना बहुत आसान है। उदाहरण के लिए, निम्नलिखित आयात करता है <code>puts</code> [[सी पुस्तकालय|C लाइब्रेरी]] से कार्य करता है और स्ट्रिंग को प्रिंट करने के लिए इसका उपयोग करता है <code>"Hello, world!"</code> टर्मिनल पर:
extern int puts(char*);
hello = puts "Hello, world!";
hello;


== यह भी देखें ==
== यह भी देखें ==
Line 134: Line 118:


== संदर्भ ==
== संदर्भ ==
* Albert Gräf. "Signal Processing in the Pure Programming Language". ''Linux Audio Conference 2009''.
* Albert Gräf. "Signal Processing in the शुद्ध (प्रोग्रामिंग भाषा) Programming Language". ''Linux Audio Conference 2009''.
* Michael Riepe. [http://www.heise.de/ix/artikel/Rein-ins-Vergnuegen-856225.html "Pure – eine einfache funktionale Sprache"]. ''Heise''.
* Michael Riepe. [http://www.heise.de/ix/artikel/Rein-ins-Vergnuegen-856225.html "शुद्ध (प्रोग्रामिंग भाषा) – eine einfache funktionale Sprache"]. ''Heise''.
* [https://web.archive.org/web/20130808212022/http://blueparen.com/node/6 "Interview With Albert Gräf"]. blueparen.
* [https://web.archive.org/web/20130808212022/http://blueparen.com/node/6 "Interview With Albert Gräf"]. blueparen.


Line 146: Line 130:
==बाहरी संबंध==
==बाहरी संबंध==
* {{Official website|https://agraef.github.io/pure-lang/}}
* {{Official website|https://agraef.github.io/pure-lang/}}
* [http://puredocs.bitbucket.org/ Pure language and library documentation]
* [http://puredocs.bitbucket.org/ शुद्ध (प्रोग्रामिंग भाषा) language and library documentation]
* [http://purelang.bitbucket.org/quickref/pure-quickref.pdf Pure quick reference]
* [http://purelang.bitbucket.org/quickref/pure-quickref.pdf शुद्ध (प्रोग्रामिंग भाषा) quick reference]
* [http://code.google.com/p/pure-lang/wiki/PurePrimer0 Pure Primer]
* [http://code.google.com/p/pure-lang/wiki/PurePrimer0 शुद्ध (प्रोग्रामिंग भाषा) Primer]


{{Programming languages}}
{{Programming languages}}

Revision as of 17:40, 7 March 2023

Pure
File:Pure lang logo.png
ParadigmFunctional, declarative, term rewriting
द्वारा डिज़ाइन किया गयाAlbert Gräf
DeveloperAlbert Gräf
पहली प्रस्तुति2008; 16 years ago (2008)
Stable release
0.68 / 11 April 2018; 6 years ago (2018-04-11)
टाइपिंग अनुशासनStrong, dynamic
ओएसCross-platform: FreeBSD, Linux, macOS, Windows
लाइसेंसGNU Lesser General Public License
वेबसाइटagraef.github.io/pure-lang/
Influenced by
Q, Haskell, Lisp, Alice, MATLAB

शुद्ध, समीकरण भाषा Q के आनुक्रमिक, गतिशील रूप से टाइप की गई, कार्यात्मक प्रोग्रामिंग भाषा है जो शब्द पुनर्लेखन पर आधारित है। इसमें यूजर-डिफ़ाइंड ऑपरेटर (प्रोग्रामिंग) सिंटैक्स, मैक्रो (कंप्यूटर विज्ञान), यादृच्छिक-परिशुद्धता अंकगणित (बहु-परिशुद्धता संख्या) और एलएलवीएम के माध्यम से प्राकृत कूट के संकलन की सुविधा है। शुद्ध जीएनयू लेसर जनरल पब्लिक लाइसेंस वर्जन 3 या बाद के संस्करण के तहत वितरित (ज्यादातर) निःशुल्क और मुक्तस्रोत सॉफ्टवेयर है।

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

शुद्ध भाषा समतुल्य प्रोग्रामिंग भाषा Q का आनुक्रमिक है, जो पहले जर्मनी के मेनज़ विश्वविद्यालय में एक ही लेखक अल्बर्ट ग्राफ द्वारा बनाई गई थी। Q के सापेक्ष, यह कुछ महत्वपूर्ण नई सुविधाएँ प्रदान करता है (जैसे कि लेक्सिकल स्कूपिंग, कुशल वेक्टर और मैट्रिक्स सपोर्ट के साथ स्थानीय फ़ंक्शंस, और बिल्ट-इन C इंटरफ़ेस) और प्रोग्राम बहुत तेज़ी से चलते हैं क्योंकि वे फ्लाई पर मूल कोड के लिए जस्ट-इन-टाइम संकलन हैं। शुद्ध वर्तमान में ज्यादातर गणितीय अनुप्रयोगों और वैज्ञानिक कंप्यूटिंग के उद्देश्य से है, लेकिन इसका पारस्परिक दुभाषिया परिसर, C इंटरफ़ेस और ऐडऑन मॉड्यूल का बढ़ता सेट इसे कई अन्य अनुप्रयोगों जैसे कि कृत्रिम बुद्धिमत्ता, प्रतीकात्मक संगणना और वास्तविक समय मल्टीमीडिया प्रसंस्करण के लिए उपयुक्त बनाता है, ।

शुद्ध प्लग-इन (कंप्यूटिंग) ग्नुमेरिक स्प्रेडशीट और मिलर पकेट के शुद्ध डेटा ग्राफिकल मल्टीमीडिया सॉफ़्टवेयर के लिए उपलब्ध हैं, जो शुद्ध भाषा में लिखे गए कार्यों के साथ इन प्रोग्रामों को विस्तारित करना संभव बनाते हैं। जीएनयू ऑक्टेव, ओपनसीवी, ओपनजीएल, जीएनयू वैज्ञानिक लाइब्रेरी, एफएयूएसटी (प्रोग्रामिंग लैंग्वेज), सुपर कोलाइडर, और लिब्लो (ओपन साउंड कंट्रोल (ओएससी) के लिए) को लाइब्रेरी मॉड्यूल के रूप में इंटरफेस भी प्रदान किए जाते हैं।

उदाहरण

फाइबोनैचि संख्या (भोले संस्करण):

fib 0 = 0;
fib 1 = 1;
fib n = fib (n-2) + fib (n-1) if n>1;

बेहतर (टेल-रिकर्सिव और लीनियर-टाइम) संस्करण:

 fib n = fibs (0,1) n with
  fibs (a,b) n = if n<=0 then a else fibs (b,a+b) (n-1);
end;

पहले 20 फाइबोनैचि संख्याओं की गणना करें:

map fib (1..20);

एन क्वीन्स प्रॉब्लम के लिए कलन विधि जो बैकट्रैकिंग खोज को व्यवस्थित करने के लिए सूची समझ को नियोजित करता है:

 queens n = search n 1 [] with
  search n i p  = [reverse p] if i>n;
                = cat [search n (i+1) ((i,j):p) | j = 1..n; safe (i,j) p];
  safe (i,j) p  = ~any (check (i,j)) p;
  check (i1,j1) (i2,j2)
                = i1==i2 || j1==j2 || i1+j1==i2+j2 || i1-j1==i2-j2;
end;

जबकि शुद्ध डिफ़ॉल्ट रूप से उत्सुक मूल्यांकन का उपयोग करता है, यह लज़ी मूल्यांकन डेटा संरचनाओं जैसे धाराओं (लज़ी सूची (कंप्यूटिंग)) का भी समर्थन करता है। उदाहरण के लिए, डेविड टर्नर (कंप्यूटर वैज्ञानिक) का कलन विधि[1] परीक्षण प्रभाग द्वारा अभाज्य संख्याओं की धारा की गणना के लिए शुद्ध में व्यक्त किया जा सकता है:

 primes = sieve (2..inf) with
  sieve (p:qs) = p : sieve [q | q = qs; q mod p] &;
end;

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

primes!!(0..99); // yields the first 100 primes

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

gauss_elimination x::matrix = p,x when n,m = dim x; p,_,x = foldl step (0..n-1,0,x) (0..m-1) end;
step (p,i,x) j = if max_x==0 then p,i,x else
   // updated row permutation and index:
   transp i max_i p, i+1,
   {// the top rows of the matrix remain unchanged:
    x!!(0..i-1,0..m-1);
    // the pivot row, divided by the pivot element:
    {x!(i,l)/x!(i,j)                 | l=0..m-1};
    // subtract suitable multiples of the pivot row:
    Template:X!(k,l)-x!(k,j)*x!(i,l)/x!(i,j)
when
 n,m = dim x; max_i, max_x = pivot i (col x j);
 x = if max_x>0 then swap x i max_i else x;
end with
 pivot i x = foldl max (0,0) [j,abs (x!j)|j=i..#x-1];
 max (i,x) (j,y) = if x<y then j,y else i,x;
end;
/* Swap rows i and j of the matrix x. */
swap x i j = x!!(transp i j (0..n-1),0..m-1) when n,m = dim x end;
/* Apply a transposition to a permutation. */
transp i j p = [p!tr k | k=0..#p-1] with tr k = if k==i then j else if k==j then i else k end;
/* Example: */
let x = dmatrix {2,1,-1,8; -3,-1,2,-11; -2,1,2,-3}; x; gauss_elimination x;

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

expand = reduce with
  (a+b)*c = a*c+b*c;
  a*(b+c) = a*b+a*c;
end;

factor = reduce with
  a*c+b*c = (a+b)*c;
  a*b+a*c = a*(b+c);
end;

expand ((a+b)*2); // yields a*2+b*2
factor (a*2+b*2); // yields (a+b)*2

शुद्ध (प्रोग्रामिंग भाषा) से C (प्रोग्रामिंग लैंग्वेज) फंक्शन को कॉल करना बहुत आसान है। उदाहरण के लिए, निम्नलिखित आयात करता है puts C लाइब्रेरी से कार्य करता है और स्ट्रिंग को प्रिंट करने के लिए इसका उपयोग करता है "Hello, world!" टर्मिनल पर:

extern int puts(char*);
hello = puts "Hello, world!";
hello;

यह भी देखें

संदर्भ


टिप्पणियाँ

  1. Turner, David A. SASL language manual. Tech. rept. CS/75/1. Department of Computational Science, University of St. Andrews 1975.


बाहरी संबंध