PDL::BadValuesp - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

PDL::BadValues ​​- PDL में खराब मूल्य समर्थन की चर्चा

वर्णन

क्या रहे बुरा मानों और क्यों चाहिए I नाक में दम करना साथ में उन्हें?
कभी-कभी यह निर्दिष्ट करने में सक्षम होना उपयोगी होता है कि कोई निश्चित मान 'खराब' है या 'लापता' है; के लिए
उदाहरण के लिए खगोल विज्ञान में उपयोग किए जाने वाले सीसीडी 2डी छवियां उत्पन्न करते हैं जो कुछ क्षेत्रों के लिए सही नहीं होते हैं
डिटेक्टर में खामियों के कारण अमान्य डेटा शामिल है। जबकि पीडीएल का शक्तिशाली सूचकांक
रूटीन और डेटाफ्लो, स्लाइस आदि के साथ सभी जटिल व्यवसाय का मतलब है कि ये
प्रसंस्करण में क्षेत्रों को नजरअंदाज किया जा सकता है, ऐसा करना अजीब है। यह होना बहुत आसान होगा
"$c = $a + $b" कहने में सक्षम और सारी परेशानी कंप्यूटर पर छोड़ दें।

यदि आपकी इसमें रुचि नहीं है, तो आप (सही रूप से) इस बारे में चिंतित हो सकते हैं कि यह कैसे होगा
पीडीएल की गति को प्रभावित करता है, क्योंकि प्रत्येक ऑपरेशन में खराब मूल्य की जांच करने का ओवरहेड होता है
बड़ा हो सकता है. इस वजह से, कोड को यथासंभव तेज़ बनाने के लिए लिखा गया है -
विशेष रूप से उन पिडल्स पर संचालन करते समय जिनमें खराब मान नहीं होते हैं। वास्तव में, आप
पिडल्स के साथ काम करते समय अनिवार्य रूप से कोई गति अंतर नहीं देखना चाहिए जो ऐसा नहीं करता है
ख़राब मान शामिल हैं.

हालाँकि, यदि आप खराब मान नहीं चाहते हैं, तो पीडीएल का "WITH_BADVAL" कॉन्फ़िगरेशन विकल्प
बचाव के लिए आता है; यदि 0 या अनडिफ़ पर सेट किया गया है, तो खराब-मूल्य समर्थन को अनदेखा कर दिया जाता है। के बारे में
केवल एक बार मुझे लगता है कि आपको इसका उपयोग करने की आवश्यकता होगी - मैं मानता हूं, मैं पक्षपाती हूं ;) - यदि आपके पास है
सीमित डिस्क या मेमोरी स्थान, क्योंकि कोड का आकार बढ़ गया है (नीचे देखें)।

आप यह भी पूछ सकते हैं 'ठीक है, मेरा कंप्यूटर IEEE NaN का समर्थन करता है, इसलिए मेरे पास यह पहले से ही है'। पूर्ण रूप से हाँ
और नहीं - कई रूटीन, जैसे "y=sin(x)", उपयोगकर्ता के बिना NaN का प्रचार करेंगे
अलग-अलग तरीके से कोड करने के लिए, लेकिन "qsort", या किसी सरणी के मध्य को खोजने जैसी दिनचर्या की आवश्यकता होती है
ख़राब मानों को संभालने के लिए पुनः कोडित किया जाना। फ़्लोटिंग-पॉइंट डेटाटाइप के लिए, "NaN" और "Inf" हैं
ख़राब मूल्यों को चिह्नित करने के लिए उपयोग किया जाता है IF आपकी कॉन्फ़िगरेशन फ़ाइल में विकल्प "BADVAL_USENAN" 1 पर सेट है।
अन्यथा विशेष मानों का उपयोग किया जाता है (डिफ़ॉल्ट ख़राब मान)। मेरे पास इसके लिए कोई बेंचमार्क नहीं है
देखें कि कौन सा विकल्प तेज़ है.

एक प्रायोगिक सुविधा "BADVAL_PER_PDL" है, जो सेट होने पर आपको इसकी अनुमति देती है
एक ही प्रकार की अलग-अलग पहेलियों के लिए अलग-अलग ख़राब मान। यह वर्तमान में काम नहीं करता है
"BADVAL_USENAN" विकल्प के साथ; यदि दोनों सेट हैं तो पीडीएल "BADVAL_USENAN" को अनदेखा कर देगा
मूल्य.

कोड वृद्धि दो सेवा मेरे बुरा मानों
निम्नलिखित तुलना पुरानी हो चुकी है!

Linux और Perl 386_5.005 चलाने वाली i03 मशीन पर, मैंने निम्नलिखित आकार मापे (
स्लेटेक कोड संकलित किया गया था, लेकिन अन्य विकल्पों में से कोई नहीं: उदाहरण के लिए, एफएफटीडब्ल्यू, जीएसएल, और ट्राइडी
थे):

with_BADVAL = 0
सफल मेक के बाद ब्लिब निर्देशिका का आकार = 4963 kb: ब्लिब/आर्क = 2485 केबी और
ब्लिब/लिब = 1587 केबी।

with_BADVAL = 1
सफल मेक के बाद ब्लिब निर्देशिका का आकार = 5723 kb: ब्लिब/आर्क = 3178 केबी और
ब्लिब/लिब = 1613 केबी।

तो, कुल मिलाकर वृद्धि है केवल 15% - उन सभी आश्चर्यों के लिए भुगतान करने के लिए बहुत अधिक नहीं है जो खराब मूल्य रखते हैं
प्रदान करता है ;)

इस परीक्षण के लिए उपयोग किए गए स्रोत कोड में अधिकांश मुख्य रूटीन (उदाहरण के लिए) थे
बेसिक/) को खराब मानों के उपयोग में परिवर्तित कर दिया गया, जबकि बहुत कम 'बाहरी' रूटीन (अर्थात्) को उपयोग में लाया गया
पीडीएल वितरण में बाकी सब कुछ बदल दिया गया था।

A त्वरित सिंहावलोकन
पीडीएल> पी $पीडीएल::खराब::स्थिति
1
पीडीएल> $ए = अनुक्रम(4,3);
पीडीएल> पी $ए
[
[0 1 2 3]
[4 5 6 7]
[8 9 10 11]
]
पीडीएल> $ए = $ए->सेटबैडिफ़( $ए % 3 == 2 )
पीडीएल> पी $ए
[
[ 0 1 ख़राब 3 ]
[4 बुरा 6 7]
[बुरा 9 10 बुरा]
]
पीडीएल> $ए *=3
पीडीएल> पी $ए
[
[ 0 3 ख़राब 9 ]
[12 बुरा 18 21]
[बुरा 27 30 बुरा]
]
पीडीएल> पी $ए->योग
120

Perldl या pdl2 के भीतर "डेमो बैड" और "डेमो बैड2" कुछ का प्रदर्शन देता है
बुरे मूल्यों के साथ चीजें संभव हैं। ये पीडीएल की वेबसाइट पर भी उपलब्ध हैं
http://pdl.perl.org/demos/. खराब मूल्यों के साथ काम करने के लिए उपयोगी दिनचर्या के लिए PDL::Bad देखें
और t/ख़राब.t उन्हें कार्रवाई में देखने के लिए।

इरादा यह है:

· उन उपयोगकर्ताओं के लिए पीडीएल को महत्वपूर्ण रूप से प्रभावित नहीं करता जिन्हें खराब मूल्य समर्थन की आवश्यकता नहीं है

· ख़राब मूल्य समर्थन स्थापित होने पर यथासंभव तेज़ रहें

यदि आप कभी भी खराब मूल्य समर्थन नहीं चाहते हैं, तो आप "WITH_BADVAL" को 0 पर सेट करें perldl.conf; पीडीएल
फिर इसमें कोई खराब मूल्य समर्थन संकलित नहीं है, इसलिए यह उतना ही तेज़ होगा जितना पहले हुआ करता था।

हालाँकि, ज्यादातर मामलों में, खराब मूल्य समर्थन का गति पर नगण्य प्रभाव पड़ता है, इसलिए आप
"WITH_CONFIG" को 1 पर सेट करना चाहिए! एक अपवाद यह है कि यदि आपकी याददाश्त कम है, तो मात्रा के बाद से
उत्पादित कोड की मात्रा अधिक है (लेकिन केवल लगभग 15% - देखें "खराब होने के कारण कोड में वृद्धि।"
मान")।

यह पता लगाने के लिए कि क्या पीडीएल को खराब मूल्य समर्थन के साथ संकलित किया गया है, दोनों में से किसी एक के मूल्यों को देखें
$PDL::Config{WITH_BADVAL} या $PDL::Bad::Status - यदि सत्य है तो यह सत्य है।

यह पता लगाने के लिए कि क्या कोई रूटीन ख़राब मानों का समर्थन करता है, perldl या pdl2 में " Badinfo " कमांड का उपयोग करें
या pdldoc के लिए "-b" विकल्प। यह सुविधा वर्तमान में 'अवधारणा का प्रमाण' (या, अधिक) है
वास्तविक रूप से, एक त्वरित हैक) इसलिए उम्मीद करें कि यह किनारों के आसपास खुरदुरा होगा।

प्रत्येक पिडल में एक ध्वज होता है - "$pdl-> Badflag" के माध्यम से पहुंच योग्य - यह बताने के लिए कि क्या कोई है
ख़राब डेटा मौजूद:

· अगर असत्य/0, जिसका अर्थ है कि यहां कोई ख़राब डेटा नहीं है, कोड "कोड" द्वारा प्रदान किया गया है
"pp_def()" का विकल्प निष्पादित किया गया है। इसका मतलब है कि गति बहुत करीब होनी चाहिए
जो कि "WITH_BADVAL=0" के साथ प्राप्त हुआ, क्योंकि एकमात्र ओवरहेड ए तक कई पहुंच है
पिडल्स स्टेट वेरिएबल में बिट।

· अगर सत्य/1, तो यह वहां कहता है हो सकता है पहेली में खराब डेटा हो, इसलिए कोड का उपयोग करें
"बैडकोड" विकल्प (यह मानते हुए कि इस रूटीन के लिए "pp_def()" को अपडेट कर दिया गया है
BadCode कुंजी हो)। आपको थ्रेडिंग के सभी लाभ मिलते हैं, जैसा कि "कोड" से होता है
विकल्प, लेकिन यह धीमी गति से चलेगा क्योंकि आपको इसकी उपस्थिति को संभालना होगा
बुरे मूल्य.

यदि आप एक पिडल बनाते हैं, तो इसका खराब-मूल्य ध्वज 0 पर सेट होगा। इसे बदलने के लिए, इसका उपयोग करें
"$pdl-> Badflag($new_ Bad_status)", जहां $new_ Bad_status 0 या 1 हो सकता है। जब एक रूटीन
एक पिडल बनाता है, इसका खराब-मूल्य ध्वज इनपुट पिडल्स पर निर्भर करेगा: जब तक कि ओवर-राइड न हो
("कॉपीबैडस्टैटसकोड" विकल्प को "पीपी_डीईएफ" पर देखें), खराब-मूल्य ध्वज को सही सेट किया जाएगा यदि
किसी भी इनपुट पडल में ख़राब मान हैं। यह जाँचने के लिए कि किसी ढेर में वास्तव में कुछ ख़राब है
डेटा, "चेक_बैडफ्लैग" विधि का उपयोग करें।

ध्यान दें: बुरे झंडे का प्रचार

यदि आप किसी पिडल का बैडफ्लैग बदलते हैं, तो यह परिवर्तन सभी पर प्रसारित हो जाता है के बच्चे एक की
पहेली, तो

पीडीएल> $ए = शून्य(20,30);
पीडीएल> $बी = $ए->स्लाइस('0:10,0:10');
पीडीएल> $सी = $बी->स्लाइस(',(2)');
पीडीएल> प्रिंट ">>सी:", $सी->बैडफ्लैग, "\n";
>>सी: 0
पीडीएल> $a->ख़राबफ़्लैग; (1)
पीडीएल> प्रिंट ">>सी:", $सी->बैडफ्लैग, "\n";
>>सी: 1

नहीं पिडल के माता-पिता में परिवर्तन किया जाता है, इसलिए

पीडीएल> प्रिंट ">>ए:", $ए->बैडफ्लैग, "\n";
>>ए: 1
पीडीएल> $सी->ख़राबफ़्लैग; (0)
पीडीएल> प्रिंट ">>ए:", $ए->बैडफ्लैग, "\n";
>>ए: 1

विचार:

· ख़राब फ़्लैग को केवल तभी साफ़ किया जा सकता है जब किसी पिडल का कोई माता-पिता न हो, और यह परिवर्तन होगा
उस पहेली के सभी बच्चों तक प्रचार करें। मैं भी अब इसके लिए उतना उत्सुक नहीं हूं
कोड करना अजीब है, एक के लिए)।

· "$a->ख़राबफ़्लैग(1)" को माता-पिता और बच्चों दोनों के बीच गलत संदेश का प्रचार करना चाहिए।

इसे लागू करना कठिन नहीं होना चाहिए (हालाँकि प्रारंभिक प्रयास विफल रहा!)। क्या यह बनाता है
फिर भी समझ में आया? यह मुद्दा भी है कि यदि आप a का ख़राब मान बदलते हैं तो क्या होगा
पहेली - क्या इन्हें बच्चों/माता-पिता तक प्रचारित किया जाना चाहिए (हाँ) या केवल आपको ही ऐसा करना चाहिए
'शीर्ष' स्तर पर बैडवैल्यू को बदलने में सक्षम - यानी उन पडल्स जिनमें नहीं है
माता-पिता।

"उत्पत्ति_बैडवैल्यू ()" विधि किसी दिए गए डेटाटाइप के लिए संकलन-समय मान लौटाती है। यह काम करता है
पिडल्स पर, पीडीएल::टाइप ऑब्जेक्ट्स, और संख्याएँ - उदाहरण के लिए

$पीडीएल->ओरिजिनलबैडवैल्यू(), बाइट->ओरिजिनलबैडवैल्यू(), और मूल_खराबमूल्य(4).

इसका एक भयानक नाम भी है...

वर्तमान खराब मान प्राप्त करने के लिए, "बैडवैल्यू()" विधि का उपयोग करें - इसका सिंटैक्स भी वैसा ही है
"मूल_बैडवैल्यू()"।

वर्तमान ख़राब मान को बदलने के लिए, ख़राबवैल्यू पर नया नंबर प्रदान करें - उदाहरण के लिए

$pdl->बैडवैल्यू(2.3), बाइट->ख़राब मूल्य(2), ख़राब मान(5,-3e34)।

नोट: मान चुपचाप सही सी प्रकार में परिवर्तित हो जाता है, और वापस आ जाता है - यानी
"बाइट->बैडवैल्यू(-26)" मेरी लिनक्स मशीन पर 230 लौटाता है। यह तैरने के लिए एक "नोप" भी है-
बिंदु प्रकार जब "BADVAL_USENAN" सत्य है।

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

बुरा मानों और बूलियन ऑपरेटरों
पीडीएल::ऑप्स में उन बूलियन ऑपरेटरों के लिए, खराब मान पर मूल्यांकन खराब मान लौटाता है।
जबकि इसका मतलब ये है

$मास्क = $img > $थ्रेश;

यह बुरे मूल्यों का सही ढंग से प्रचार करता है मर्जी जैसे चेक के लिए समस्याएँ पैदा करना

do_something() यदि कोई हो ($img > $thresh );

जिसे कुछ इस प्रकार पुनः लिखने की आवश्यकता है

do_something() यदि कोई हो( set Badtoval( ($img > $thresh), 0 ) );

PDL::Ufunc में 'प्रोजेक्शन' फ़ंक्शंस में से किसी एक का उपयोग करते समय - जैसे ऑरओवर - ख़राब मान
छोड़ दिए गए हैं (वर्तमान (खराब) प्रबंधन के लिए इन कार्यों के दस्तावेज़ देखें
उस स्थिति में जब सभी तत्व खराब हों)।

A बुरा मूल्य एसटी से प्रत्येक पहेली, और सम्बंधित मुद्दों
An प्रयोगात्मक विकल्प "BADVAL_PER_PDL" जोड़ा गया है perldl.conf प्रति-पिडल की अनुमति देने के लिए
बुरे मूल्य. इस परिवर्तन को ध्यान में रखते हुए दस्तावेज़ीकरण को अद्यतन नहीं किया गया है।

निम्नलिखित केवल पूर्णांक प्रकारों के लिए और फ़्लोटिंग-पॉइंट प्रकारों के लिए प्रासंगिक है
पीडीएल के निर्माण के समय "BADVAL_USENAN" सेट नहीं किया गया था।

वर्तमान में, प्रत्येक डेटाटाइप के लिए एक ख़राब मान है। कोड इसलिए लिखा गया है ताकि हम ऐसा कर सकें
प्रत्येक पिडल के लिए एक अलग खराब मान है (पीडीएल संरचना में संग्रहीत) - यह तब होगा
वर्तमान समस्या को दूर करें:

पीडीएल> $ए = बाइट(1, 2, बाइट->बैडवैल्यू, 4, 5);
पीडीएल> पी $ए;
[1 2 255 4 5 XNUMX]
पीडीएल> $a->ख़राबफ़्लैग(1)
पीडीएल> पी $ए;
[1 2 बुरा 4 5]
पीडीएल> बाइट->ख़राब मूल्य; (0)
पीडीएल> पी $ए;
[1 2 255 4 5 XNUMX]

यानी $a में ख़राब मान अपना खो चुका है बुरा वर्तमान कार्यान्वयन का उपयोग कर स्थिति. यह होगा
हालाँकि लगभग निश्चित रूप से अन्यत्र समस्याएँ पैदा होती हैं!

कार्यान्वयन विवरण

"perl Makefile.PL" के दौरान, फ़ाइल बेसिक/कोर/बैडसपोर्ट.पी बनाया गया है; यह फ़ाइल
इसमें "WITH_BADVAL", "BADVAL_USENAN" और "BADVAL_PER_PDL" वेरिएबल के मान शामिल हैं,
और उस कोड द्वारा उपयोग किया जाना चाहिए जो इससे पहले निष्पादित होता है पीडीएल::कॉन्फिग फ़ाइल बनाई गई है (उदा
बेसिक/कोर/pdlcore.c.PL. हालाँकि, अधिकांश पीडीएल कोड को केवल %PDL::Config तक पहुंचने की आवश्यकता होगी
सरणी (उदा बेसिक/ख़राब/ख़राब.पी.डी) यह पता लगाने के लिए कि क्या खराब-मूल्य समर्थन की आवश्यकता है।

पिडल की स्थिति में एक नया ध्वज जोड़ा गया है - "PDL_BADVAL"। यदि परेशान है, तो
piddle में ख़राब मान नहीं हैं, और इसलिए सभी समर्थन कोड को अनदेखा किया जा सकता है। यदि सेट हो तो यह
यह गारंटी नहीं देता कि ख़राब मान मौजूद हैं, बस उनकी जाँच की जानी चाहिए।
क्रिस्चियन को धन्यवाद, "बैडफ्लैग()" - जो इस ध्वज को सेट/साफ करता है (देखें)। बेसिक/ख़राब/ख़राब.पी.डी) -
जाएगा अद्यतन सब यदि किसी पिडल की स्थिति बदलती है तो उसके बच्चे/पोते/पोते/आदि (देखें)
"बैडफ्लैग" में बेसिक/ख़राब/ख़राब.पी.डी और "प्रोपेगेट_बैडफ्लैग" में बेसिक/कोर/कोर.xs.PL). यह
स्पष्ट करें कि माता-पिता के साथ क्या करना है: मैं 'सेट बैडफ्लैग' के प्रचार का कारण देख सकता हूँ
माता-पिता से अनुरोध है, लेकिन मुझे लगता है कि एक बच्चे को खराब झंडे को साफ़ करने में सक्षम नहीं होना चाहिए
अभिभावक. यह भी मुद्दा है कि जब आप किसी के लिए खराब मान बदलते हैं तो क्या होता है
पहेली.

"pdl_trans" संरचना को एक पूर्णांक मान, "bvalflag" को शामिल करने के लिए विस्तारित किया गया है, जो
यह कोड को यह बताने के लिए एक स्विच के रूप में कार्य करता है कि खराब मानों को संभालना है या नहीं। यह मान निर्धारित है
यदि किसी भी इनपुट पडल का अपना "PDL_BADVAL" फ़्लैग सेट है (हालाँकि यह कोड हो सकता है
pp_def में "FindBadStateCode" सेट करके प्रतिस्थापित किया गया)। चेक का तर्क मिलने वाला है
यदि मैं रूटीन को "कोड" अनुभाग का उपयोग करने की अनुमति दे दूं तो यह थोड़ा अधिक जटिल हो जाएगा
फ़्लोटिंग-पॉइंट प्रकार (यानी "NoBadifNaN => 1" वाले वे रूटीन जब "BADVAL_USENAN" होते हैं
सत्य)।

पूर्णांक प्रकारों के खराब मान अब कोर पीडीएल के भीतर एक संरचना में संग्रहीत हैं
संरचना - "PDL.bvals" (उदा बेसिक/कोर/pdlcore.h.PL); इसमें "टाइपडीफ़ बैडवल्स" भी देखें
बेसिक/कोर/पीडीएल.एच.पीएल और का BOOT कोड बेसिक/कोर/कोर.xs.PL मूल्य कहां हैं
(उम्मीद है) समझदार मूल्यों के लिए आरंभिक। देखना पीडीएल/खराब/खराब.पीडी पढ़ने/लिखने की दिनचर्या के लिए
मूल्य।

"BADVAL_PER_PDL" विकल्प को जोड़ने के परिणामस्वरूप इसमें अतिरिक्त परिवर्तन हुए हैं
पिडल्स के आंतरिक भाग। ये परिवर्तन अभी तक प्रलेखित नहीं हैं.

क्यों नहीं बनाना a पीडीएल उपवर्ग?
ख़राब मूल्यों का समर्थन पीडीएल उप-वर्ग के रूप में किया जा सकता था। इसका फायदा
दृष्टिकोण यह होगा कि यदि आप वास्तव में चाहें तो केवल खराब मानों को संभालने के लिए कोड लोड करें
उनका उपयोग करने के लिए. नकारात्मक पक्ष यह है कि कोड फिर अलग हो जाता है: कोई भी बग
कोड में दो अलग-अलग फाइलों में सुधार/सुधार किया जाना है। वर्तमान के साथ
दृष्टिकोण कोड उसी "pp_def" फ़ंक्शन में है (हालाँकि अभी भी समस्या है
कि "कोड" और "बैडकोड" दोनों अनुभागों को अद्यतन करने की आवश्यकता है)।

चूक बुरा मानों
डिफ़ॉल्ट/मूल ख़राब मान इस पर सेट हैं (स्टारलिंक वितरण से लिया गया):

#शामिल करना

पीडीएल_बाइट == UCHAR_MAX
पीडीएल_शॉर्ट == SHRT_MIN
PDL_Ushort == USHRT_MAX
PDL_लंबा == INT_MIN

यदि "BADVAL_USENAN == 0", तो हमारे पास भी है

पीडीएल_फ्लोट == -FLT_MAX
पीडीएल_डबल == -डीबीएल_मैक्स

अन्यथा सभी "NaN", "+Inf", और "-Inf" को फ़्लोटिंग-पॉइंट प्रकारों के लिए ख़राब माना जाता है।
इस मामले में, पूर्णांक प्रकारों के विपरीत, खराब मान को बदला नहीं जा सकता है।

कैसे do I परिवर्तन a सामान्य सेवा मेरे संभालना बुरा मूल्य?
उदाहरण अधिकांश में पाए जा सकते हैं *.पी.डी फाइलों में बुनियादी/ (और उम्मीद है कि कई और जगहें
जल्दी!)। कुछ तर्क थोड़े अस्पष्ट लग सकते हैं - शायद ऐसा इसलिए है क्योंकि यह है!
टिप्पणियों की सराहना की गई.

सभी रूटीनों को स्वचालित रूप से खराब स्थिति ध्वज को आउटपुट पिडल्स में प्रचारित करना चाहिए, जब तक कि
आप अन्यथा घोषित करें.

यदि कोई रूटीन स्पष्ट रूप से खराब मूल्यों से निपटता है, तो आपको pp_def को यह विकल्प प्रदान करना होगा:

हैंडलबैड => 1

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

किसी रूटीन को ख़राब मानों को न संभाल पाने के रूप में चिह्नित करने के लिए, इसका उपयोग करें

हैंडलबैड => 0

इस चाहिए यदि रूटीन को कोई खराब संदेश भेजा जाता है तो उसे चेतावनी छापने को कहें
ध्वज सेट. आदिम के "इनओवर" में यह सेट है - चूँकि इसे परिवर्तित करना अजीब होगा -
लेकिन मैंने यह देखने की कोशिश नहीं की है कि यह काम करता है या नहीं।

यदि आप खराब मानों को संभालना चाहते हैं लेकिन सभी आउटपुट पडलों की स्थिति निर्धारित नहीं करना चाहते हैं, या यदि
यह केवल एक इनपुट पहेली है जो महत्वपूर्ण है, फिर पीपी नियमों को देखें
"NewXSFindBadStatus" और "NewXSCopyBadStatus" और संबंधित "pp_def" विकल्प:

खराब स्थिति कोड खोजें
डिफ़ॉल्ट रूप से, "FindBadStatusCode" कोड बनाता है जो इसके आधार पर "$PRIV(bvalflag)" सेट करता है
इनपुट पडल्स के ख़राब फ़्लैग की स्थिति: "find Badstatus" देखें
बेसिक/जनरल/पीपी.पी.एम. उपयोगकर्ता-परिभाषित कोड को "bvalflag" का मान भी संग्रहीत करना चाहिए
"$BADFLAGCACHE()" वैरिएबल।

CopyBadStatusCode
यहां डिफ़ॉल्ट कोड "FindBadStatusCode" की तुलना में थोड़ा सरल है: का खराब ध्वज
यदि कोड के बाद "$BADFLAGCACHE()" सत्य है तो आउटपुट पिडल सेट किए जाते हैं
मूल्यांकन किया गया। कभी-कभी "CopyBadStatusCode" को एक खाली स्ट्रिंग पर सेट किया जाता है
आउटपुट पिडल के बैडफ्लैग को सेट करने की जिम्मेदारी "बैडकोड" पर छोड़ दी गई है
अनुभाग (उदाहरण के लिए "xxxover" रूटीन मूल/आदिम/आदिम.पी.डी).

पीडीएल 2.4.3 से पहले हम "$BADFLAGCACHE()" के बजाय "$PRIV(bvalflag)" का उपयोग करते थे। यह है
खतरनाक है क्योंकि इस बिंदु पर "$PRIV()" संरचना के वैध होने की गारंटी नहीं है
कोड।

यदि आपके पास कोई ऐसी दिनचर्या है जिसे आप यथास्थान उपयोग करने में सक्षम होना चाहते हैं, तो उसमें मौजूद दिनचर्याओं को देखें
ख़राब.पी.डी (या ऑप्स.पीडी) जो यह देखने के लिए "इन-प्लेस" विकल्प का उपयोग करते हैं कि खराब ध्वज का प्रचार कैसे किया जाता है
"xxxBadStatusCode" विकल्प का उपयोग करने वाले बच्चों के लिए। मैंने इसे नियमों के रूप में स्वचालित न करने का निर्णय लिया
यह थोड़ा जटिल होगा, क्योंकि प्रत्येक इन-प्लेस ऑप को बैडफ्लैग का प्रचार करने की आवश्यकता नहीं होगी
(जैसे यूनरी फ़ंक्शंस)।

यदि विकल्प

हैंडलबैड => 1

दिया जाता है, तो बहुत कुछ घटित होता है। पूर्णांक प्रकारों के लिए, रीडडेटा कोड स्वचालित रूप से
" नामक एक वैरिएबल बनाता है _बडवल", जिसमें उसके लिए ख़राब मान शामिल है
पिडल (देखें "get_xsdatapdecl()" में बेसिक/जनरल/पीपी/PdlParObjs.pm). हालाँकि, हार्ड कोड न करें
यह नाम आपके कोड में! इसके बजाय मैक्रोज़ का उपयोग करें (सुझाव के लिए टुओमास को धन्यवाद):

'$ISBAD(a(n=>1))' का विस्तार '$a(n=>1) == a_ Badval' तक होता है
'$ISGOOD(a())' '$a() != a_ Badval'
'$SETBAD(बॉब())' '$बॉब() = बॉब_बैडवल'

खैर, "$a(...)" का भी विस्तार किया गया है। इसके अलावा, यदि आप पीडीएल नाम से पहले "$" का उपयोग कर सकते हैं
आप ऐसा चाहते हैं, लेकिन यह लाइन शोर जैसा दिखने लगता है - उदाहरण के लिए "$ISGOOD($a())"।

यदि आप किसी वेरिएबल में एक पिडल मान को कैश करते हैं - उदाहरण के लिए "इंडेक्स"। स्लाइस.पीडी -- निम्नलिखित
दिनचर्या उपयोगी है:

'$ISBADVAR(c_var,pdl)' 'c_var == pdl_ Badval'
'$ISGOODVAR(c_var,pdl)' 'c_var != pdl_ Badval'
'$SETBADVAR(c_var,pdl)' 'c_var = pdl_ Badval'

निम्नलिखित को प्रस्तुत किया गया है, उन्हें अपने सुधार के लिए इनके साथ खेलने की आवश्यकता हो सकती है
का उपयोग करें.

'$PPISBAD(CHILD,[i]) 'CHILD_physdatap[i] == CHILD_ Badval'
'$PPISGOOD(CHILD,[i]) 'CHILD_physdatap[i] != CHILD_ Badval'
'$PPSETBAD(CHILD,[i]) 'CHILD_physdatap[i] = CHILD_ Badval'

यदि "BADVAL_USENAN" सेट है, तो यह "फ्लोट" और "डबल" के लिए थोड़ा अलग है, जहां हम
"NaN", "+Inf", और "-Inf" सभी को खराब मानें। इस मामले में:

ISBAD परिमित (पिडल) == 0 हो जाता है
अच्छा परिमित(पिडिल) != 0
सेटबैड पहेली = NaN

जहां NaN मानों को संभालने में NaN के मान पर नीचे चर्चा की गई है।

इसका मतलब यह है कि आप बदल सकते हैं

कोड => '$a() = $b() + $c();'

सेवा मेरे

BadCode => 'यदि ($ISBAD(b()) || $ISBAD(c()) ) {
$सेटबैड(ए());
और} {
$a() = $b() + $c();
}'

कोड को वैसे ही छोड़ें जैसे वह है। PP::PDLCode फिर कुछ इस तरह एक लूप बनाएगा

यदि ( __trans->bvalflag ) {
बैडकोड पर थ्रेडलूप
और} {
कोड पर थ्रेडलूप
}

(सिर्फ इसे देखना शायद आसान है .xs यह देखने के लिए फ़ाइल करें कि क्या होता है)।

जा रहे हैं? परे la कोड अनुभाग
"BadCode" के समान, "BadBackCode" और "BadRedoDimsCode" भी हैं।

"EquivCPOffsCode" को संभालना थोड़ा अलग है: इस धारणा के तहत कि एकमात्र पहुंच
डेटा के लिए "$EQUIVCPOFFS(i,j)" मैक्रो के माध्यम से है, तो हम स्वचालित रूप से 'खराब' बना सकते हैं
इसका संस्करण; PDL::PP में "[EquivCPOffsCode]" और "[Code]" नियम देखें।

मैक्रो पहुँच सेवा मेरे la बुरा झंडा of a बेदिली से कार्य करना
पीडीएल की खराब-ध्वज स्थिति तक पहुंच प्रदान करने के लिए मैक्रोज़ प्रदान किए गए हैं:

'$PDLSTATEISBAD(a)' -> '($PDL(a)->state & PDL_BADVAL) > 0'
'$PDLstateisgood(a)' '($PDL(a)->state & PDL_BADVAL) == 0'

'$PDLSTATESETBAD(a)' '$PDL(a)->state |= PDL_BADVAL'
'$PDLstatesetgood(a)' '$PDL(a)->state &= ~PDL_BADVAL'

"xxxxBadStatusCode" में उपयोग के लिए (+ अन्य सामग्री जो INIT: अनुभाग में जाती है) ये हैं:

'$SETPDLSTATEBAD(a)' -> 'a->state |= PDL_BADVAL'
'$SETPDLSTATEGOOD(a)' -> 'a->state &= ~PDL_BADVAL'

'$ISPDLSTATEBAD(a)' -> '((a->state & PDL_BADVAL) > 0)'
'$ISPDLSTATEGOOD(a)' -> '((a->state & PDL_BADVAL) == 0)'

पीडीएल 2.4.3 में "$BADFLAGCACHE()" मैक्रो को "FindBadStatusCode" में उपयोग के लिए पेश किया गया था और
"कॉपीबैडस्टैटसकोड"।

हैंडलिंग NaN मानों
दो मुद्दे हैं:

NaN खराब मान के रूप में
जो किया गया है. चयन करने के लिए, perldl.conf में "BADVAL_USENAN" को 1 पर सेट करें; 0 का मान गिरता है
फ़्लोटिंग-पॉइंट प्रकारों को पूर्णांकों के समान मानने पर वापस जाएँ। मुझे कुछ करने की जरूरत है
यह देखने के लिए बेंचमार्क कि कौन सा तेज़ है, और क्या यह मशीनों पर निर्भर है (लिनक्स लगता है)।
मेरे द्वारा किए गए कुछ बहुत ही सरल परीक्षणों में यह मेरी स्पार्क मशीन की तुलना में कहीं अधिक धीमी हो गई)।

BadCode अनुभागों को अनदेखा करना
जो है नहीं.

के लिए सरल फ़्लोटिंग-पॉइंट नंबरों को संसाधित करने की प्रक्रिया के लिए, हमें कंप्यूटर को प्रक्रिया करने देना चाहिए
"बैडकोड" में कोड का उपयोग करने के बजाय खराब मान (यानी "NaN" और "Inf" मान)
अनुभाग। ऐसी कई दिनचर्याओं को "NoBadifNaN => 1" का उपयोग करके लेबल किया गया है; हालाँकि यह है
वर्तमान में उपेक्षित पीडीएल द्वारा::पीपी।

इन दिनचर्याओं के लिए, हम "कोड" अनुभाग का उपयोग करना चाहते हैं

पिडल का ध्वज खराब नहीं है
डेटाटाइप एक फ्लोट या डबल है

अन्यथा हम "बैडकोड" अनुभाग का उपयोग करते हैं। यह है नहीं लागू, जैसा कि इसकी आवश्यकता होगी
PP::PDLCode की उचित हैकिंग!

यह भी समस्या है कि हम 'अपवादों' को कैसे संभालें - चूंकि "$a = पीडीएल(2) / पीडीएल(0) "
खराब मान उत्पन्न करता है लेकिन पिडल के बैडफ्लैग मान को अद्यतन नहीं करता है। क्या हम एक को पकड़ सकते हैं?
अपवाद, या क्या हमें इसके लिए जाल बिछाना होगा (उदाहरण के लिए "अपवाद" खोजें
बेसिक/ऑप्स/ऑप्स.पीडी)?

"Nan" और "Inf" की जाँच "finite()" सिस्टम कॉल का उपयोग करके की जाती है। यदि आप चाहते हैं
"NaN" मान पर एक मान सेट करें, कोड के निम्नलिखित बिट का उपयोग किया जा सकता है (यह पाया जा सकता है)।
दोनों मे बेसिक/कोर/कोर.xs.PL और बेसिक/ख़राब/ख़राब.पी.डी):

/* बड़ी-एंडियन मशीनों के लिए */
स्थिर संघ {अहस्ताक्षरित चार __c[4]; फ़्लोट __d; }
__pdl_nan = {{ 0x7f, 0xc0, 0, 0 } };

/* छोटी-छोटी मशीनों के लिए */
स्थिर संघ {अहस्ताक्षरित चार __c[4]; फ़्लोट __d; }
__pdl_nan = { { 0, 0, 0xc0, 0x7f } };

इस दृष्टिकोण को संभवतः लाइब्रेरी रूटीन जैसे "नान("")" या द्वारा प्रतिस्थापित किया जाना चाहिए
"एटोफ़("NaN")"।

यह पता लगाने के लिए कि क्या कोई विशेष मशीन बड़ी एंडियन है, रूटीन का उपयोग करें
"PDL::Core::Dev::isbigendian()"।

क्या बात हमारे बारे में（ABOUT） दस्तावेज़ीकरण?

पीडीएल की खूबियों में से एक इसका ऑनलाइन दस्तावेजीकरण है। इसका उद्देश्य इस प्रणाली का उपयोग करना है
इस बारे में जानकारी प्रदान करें कि कोई रूटीन ख़राब मानों का कैसे/क्या समर्थन करता है: कई मामलों में "pp_def()"
इसमें वैसे भी सारी जानकारी होती है, इसलिए फ़ंक्शन-लेखक को कुछ भी करने की आवश्यकता नहीं होती है
सभी! ऐसे मामलों के लिए जब यह पर्याप्त नहीं है, तो "बैडडॉक" विकल्प है। कोड के लिए
पर्ल स्तर पर लिखा गया है - अर्थात .pm फ़ाइल में - "= ख़राब के लिए" पॉड निर्देश का उपयोग करें।

यह जानकारी man/pod2man/html दस्तावेज़ीकरण के माध्यम से उपलब्ध होगी। यह भी है
"perldl" या "pdl2" शेल से पहुंच योग्य - " Badinfo " कमांड का उपयोग करके - और
"pdldoc" शेल कमांड - "-b" विकल्प का उपयोग करना।

यह समर्थन बहुत शुरुआती चरण में है - यानी इस पर ज्यादा विचार नहीं किया गया है: टिप्पणियाँ
स्वागत हैं; पसंदीदा कोड में सुधार ;) एक अजीब समस्या है *.दोपहर कोड:
आपको एक लिखना होगा *.दोपहर.पी.एल फ़ाइल जो केवल "= ख़राब के लिए" निर्देश (+ पाठ) सम्मिलित करती है
खराब मूल्य समर्थन संकलित किया गया है। वास्तव में, खराब मूल्यों को संभालते समय यह एक दर्द है
पर्ल, पीडीएल::पीपी के बजाय, स्तर: शायद मुझे "WITH_BADVAL" विकल्प को हटा देना चाहिए...

वर्तमान मुद्दें

ऐसे कई क्षेत्र हैं जिनमें काम, उपयोगकर्ता इनपुट या दोनों की आवश्यकता है! उनका उल्लेख है
इस दस्तावेज़ में कहीं और, लेकिन यह केवल यह सुनिश्चित करने के लिए है कि वे खो न जाएँ।

पकडना अमान्य गणितीय आपरेशनों
क्या हमें आउटपुट को खराब करने के लिए "पीडीएल::ऑप्स" में फ़ंक्शन में अपवाद जोड़ना चाहिए?
श्रेणी इनपुट मान?

पीडीएल> पी लॉग10(पीडीएल(10,100,-1))

मैं चाहता हूं कि उपरोक्त "[1 2 बीएडी]" का निर्माण किया जाए, लेकिन इससे परिचालन धीमा हो जाएगा सब
पहेलियाँ। हम ऑपरेशन के बाद "NaN"/"Inf" मानों की जांच कर सकते हैं, लेकिन मुझे इसमें संदेह है
और भी तेज़ होगा.

एकीकरण साथ में NaN
जब "BADVAL_USENAN" सत्य है, तो "PDL::Ops" में रूटीन को बस इसके अंतर्गत आना चाहिए
"कोड" अनुभाग - अर्थात "फ्लोट" और "डबल" डेटा प्रकारों के लिए "बैडकोड" का उपयोग न करें।

वैश्विक बनाम प्रति-पिडल बुरा मानों
मुझे लगता है कि बस "बेसिक/कोर/pdlconv.c.PL" में रूटीन को बदलने की जरूरत है, हालाँकि
जटिलताएँ अवश्य होंगी। इसका मतलब यह भी होगा कि पीडीएल संरचना की आवश्यकता होगी
इसके खराब मान को संग्रहीत करने के लिए एक वैरिएबल रखना, जिसका अर्थ होगा बाइनरी असंगति
खराब मूल्य समर्थन के साथ पीडीएल के पिछले संस्करण।

17 मार्च 2006 तक, पीडीएल में शामिल है प्रयोगात्मक "BADVAL_PER_PDL" कॉन्फ़िगरेशन विकल्प
जो चयनित होने पर प्रति-पिडल खराब मान जोड़ता है।

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

सब कुछ और

निर्माण प्रक्रिया प्रभावित हुई है. निर्माण के दौरान अब निम्नलिखित फ़ाइलें बनाई गई हैं:

बेसिक/कोर/पीडीएलकोर.एच पीडीएलकोर.एच.पीएल
pdlcore.c pdlcore.c.PL
pdlapi.c pdlapi.c.PL
Core.xs Core.xs.PL
Core.pm Core.pm.PL

कई नई फ़ाइलें जोड़ी गई हैं:

Basic/Pod/BadValues.pod (अर्थात् यह फ़ाइल)

t/ख़राब.t

बुनियादी/खराब/
बेसिक/खराब/मेकफाइल.पीएल
ख़राब.पी.डी

आदि

कार्यविधि/सुझाव

· प्रति-पिडल खराब मानों का उपयोग करने पर ध्यान दें। इसका मतलब होगा पीडीएल संरचना में बदलाव (यानी)।
बाइनरी असंगति) और "बेसिक/कोर/pdlconv.c.PL" में रूटीन की आवश्यकता होगी
इसे संभालने के लिए परिवर्तन किया जा रहा है। अधिकांश अन्य दिनचर्या चाहिए नहीं बदलने की जरूरत है...

देखना प्रयोगात्मक "BADVAL_PER_PDL" विकल्प।

· "$b = pdl(-2); $a = log10($b)" के बारे में क्या करें - $a को खराब सेट किया जाना चाहिए, लेकिन यह
वर्तमान में नहीं है.

· NaN को A के रूप में उपयोग करते समय PDL::Ops में संचालन को खराब मानों की जांच करने की अनुमति दें
ख़राब मान और फ़्लोटिंग-पॉइंट पडल को संसाधित करना। इसके लिए काफ़ी काम करने की ज़रूरत है
पीडीएल::पीपी::पीडीएलकोड।

· "$pdl-> Baddata()" अब इस पहेली के सभी बच्चों को भी अपडेट करता है। हालाँकि, नहीं
निश्चित रूप से माता-पिता के साथ क्या करना है, क्योंकि:

$बी = $ए->स्लाइस();
$बी->Baddata(0)

इसका मतलब यह नहीं है कि $a का खराब मूल्य साफ़ नहीं किया जाना चाहिए। हालाँकि, बाद में

$बी->Baddata(1)

यह मान लेना समझदारी है कि अब माता-पिता को बुरे मूल्यों वाले के रूप में चिह्नित किया जाता है।

शायद आप ख़राब मूल्य वाले फ़्लैग को केवल तभी साफ़ कर सकते हैं यदि आप किसी दूसरे के बच्चे नहीं हैं
पडल, जबकि यदि आप ध्वज सेट करते हैं तो सभी बच्चों और माता-पिता को सेट किया जाना चाहिए
कुंआ?

इसी तरह, यदि आप किसी पिडल में खराब मान बदलते हैं, तो क्या इसे प्रचारित किया जाना चाहिए
माता-पिता और बच्चे? या क्या आपको इसे केवल 'शीर्ष-स्तरीय' पहेली पर ही करने में सक्षम होना चाहिए?
बहुत खराब...

· यह देखने के लिए बेंचमार्क करने के लिए कुछ कोड सेट करें कि चीजें कितनी धीमी हो गई हैं (और तक)।
जांचें कि यदि "WITH_BADVAL" 0/undef है तो मैंने कुछ गड़बड़ तो नहीं की है)।

· कुछ नाम आकर्षक नहीं हैं - मैं "मूल_बैडवैल्यू ()" के बारे में सोच रहा हूं
बेसिक/ख़राब/ख़राब.पी.डी विशेष रूप से। किसी भी सुझाव की सराहना की जाती है.

onworks.net सेवाओं का उपयोग करके ऑनलाइन PDL::BadValuesp का उपयोग करें