जीवीपीआर - क्लाउड में ऑनलाइन

कार्यक्रम:

नाम

जीवीपीआर - ग्राफ़ पैटर्न स्कैनिंग और प्रोसेसिंग भाषा

SYNOPSIS

जीवीपीआर [-आईसीएनक्यूवी?] [ -o आउटफाइल ] [ -a आर्ग ] [ 'प्रोग' | -f progfile ] [ फ़ाइलों ]

वर्णन

जीवीपीआर (पहले के रूप में जाना जीपीआर) से प्रेरित एक ग्राफ़ स्ट्रीम संपादक है awk. यह इनपुट कॉपी करता है
इसके आउटपुट के लिए ग्राफ़, संभवतः उनकी संरचना और विशेषताओं को बदलना, नया बनाना
ग्राफ़, या मनमानी जानकारी मुद्रित करना। ग्राफ़ मॉडल वह है जो द्वारा प्रदान किया गया है
libcgraph(3). विशेष रूप से, जीवीपीआर डॉट भाषा का उपयोग करके ग्राफ़ को पढ़ता और लिखता है।

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

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

विकल्प

निम्नलिखित विकल्प समर्थित हैं:

-a आर्ग
डोर आर्ग व्यक्ति के साथ रिक्त स्थान-पृथक टोकन में विभाजित किया गया है
टोकन स्ट्रिंग के रूप में उपलब्ध हैं जीवीपीआर कार्यक्रम के रूप में एआरजीवी[0],...,ARGV[ARGC-1].
सिंगल या डबल उद्धृत सबस्ट्रिंग के भीतर व्हाइटस्पेस वर्ण, या इसके पहले
बैकस्लैश को विभाजक के रूप में नजरअंदाज कर दिया जाता है। सामान्य तौर पर, बैकस्लैश चरित्र बंद हो जाता है
निम्नलिखित वर्ण का कोई विशेष अर्थ. ध्यान दें कि टोकन प्राप्त हुए हैं
विभिन्न -a झंडे संयोजित हैं.

-c आउटपुट ग्राफ़ के रूप में स्रोत ग्राफ़ का उपयोग करें।

-i के संदर्भ में आउटपुट ग्राफ़ का नोड-प्रेरित सबग्राफ एक्सटेंशन प्राप्त करें
इसका मूल ग्राफ.

-o आउटफाइल
आउटपुट स्ट्रीम को निर्दिष्ट फ़ाइल में लिखे जाने का कारण बनता है; डिफ़ॉल्ट रूप से, आउटपुट है
करने के लिए लिखा stdout.

-f progfile
इनपुट पर निष्पादित करने के लिए प्रोग्राम के रूप में निर्दिष्ट फ़ाइल की सामग्री का उपयोग करें। अगर
progfile इसमें एक स्लैश वर्ण होता है, नाम को फ़ाइल के पथनाम के रूप में लिया जाता है।
अन्यथा, जीवीपीआर पर्यावरण चर में निर्दिष्ट निर्देशिकाओं का उपयोग करेगा
GVPRPATH फ़ाइल को खोजने के लिए. अगर -f नहीं दिया जाता है, जीवीपीआर पहले गैर का उपयोग करेंगे-
प्रोग्राम के रूप में विकल्प तर्क।

-q चेतावनी संदेश बंद कर देता है.

-n ग्राफ़ को आगे पढ़ने को बंद कर देता है। डिफ़ॉल्ट रूप से, वेरिएबल $एनजी अगले ग्राफ़ पर सेट है
संसाधित करने के लिए। इसे संसाधित करने से पहले अगले ग्राफ़ को पढ़ने की आवश्यकता है
वर्तमान ग्राफ़, जो अवरुद्ध हो सकता है यदि अगला ग्राफ़ केवल प्रतिक्रिया के रूप में उत्पन्न होता है
वर्तमान ग्राफ़ के प्रसंस्करण से संबंधित कुछ कार्रवाई।

-V प्रोग्राम को संस्करण जानकारी मुद्रित करने और बाहर निकलने का कारण बनता है।

-? प्रोग्राम को उपयोग की जानकारी प्रिंट करने और बाहर निकलने का कारण बनता है।

ऑपरेंड

निम्नलिखित ऑपरेंड समर्थित है:

फ़ाइलों डॉट भाषा में 1 या अधिक ग्राफ़ वाली फ़ाइलों के नाम। अगर कोई नहीं -f विकल्प
दिया गया है, पहला नाम सूची से हटा दिया गया है और इनपुट प्रोग्राम के रूप में उपयोग किया गया है।
यदि फ़ाइलों की सूची खाली है, stdin इस्तेमाल किया जाएगा।

कार्यक्रम

A जीवीपीआर कार्यक्रम में विधेय-क्रिया खंडों की एक सूची शामिल है, जिनमें से एक रूप है:

शुरू { कार्य }

BEG_G { कार्य }

N [ विधेय ] { कार्य }

E [ विधेय ] { कार्य }

END_जी { कार्य }

अंत { कार्य }

एक प्रोग्राम में इनमें से अधिकतम एक ही शामिल हो सकता है शुरू, END_जी और अंत खंड। सकता है
कोई भी संख्या हो BEG_G, N और E कथन, पहला ग्राफ़ पर लागू होता है, दूसरा
नोड्स, किनारों से तीसरा। इन्हें ब्लॉकों में विभाजित किया गया है, एक ब्लॉक जिसमें एक होता है
वैकल्पिक BEG_G बयान और सब कुछ N और E अगले तक के बयान BEG_G कथन, यदि
कोई भी। ए का शीर्ष-स्तरीय शब्दार्थ जीवीपीआर कार्यक्रम हैं:

मूल्यांकन करें शुरू खंड, यदि कोई हो.
प्रत्येक इनपुट ग्राफ़ के लिए G {
प्रत्येक ब्लॉक के लिए {
सेट G वर्तमान ग्राफ और वर्तमान वस्तु के रूप में।
मूल्यांकन करें BEG_G खंड, यदि कोई हो.
प्रत्येक नोड और किनारे के लिए G {
नोड या किनारे को वर्तमान ऑब्जेक्ट के रूप में सेट करें।
मूल्यांकन करें N or E खंड, जैसा उचित हो।
}
}
सेट G वर्तमान वस्तु के रूप में.
मूल्यांकन करें END_जी खंड, यदि कोई हो.
}
मूल्यांकन करें अंत खंड, यदि कोई हो.

की हरकतें शुरू, BEG_G, END_जी और अंत उपवाक्य तब निष्पादित होते हैं जब उपवाक्य होते हैं
मूल्यांकन किया गया। के लिए N or E खंड, या तो विधेय या क्रिया को छोड़ा जा सकता है। अगर वहाँ
किसी क्रिया के साथ कोई विधेय नहीं है, क्रिया प्रत्येक नोड या किनारे पर की जाती है
उचित। यदि कोई क्रिया नहीं है और विधेय सत्य का मूल्यांकन करता है, तो संबद्ध
लक्ष्य ग्राफ़ में नोड या किनारा जोड़ा जाता है।

ब्लॉकों का मूल्यांकन उनके घटित होने के क्रम में किया जाता है। एक ब्लॉक के भीतर, N खंड
(E खंड, क्रमशः) का मूल्यांकन उस क्रम में किया जाता है जिसमें घटित होता है। हालाँकि, ध्यान दें,
वह एक ब्लॉक के भीतर, N or E ट्रैवर्सल क्रम के आधार पर खंडों को आपस में जोड़ा जा सकता है।

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

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

स्थिरांक C सिंटैक्स का पालन करते हैं, लेकिन स्ट्रिंग्स को किसी के साथ उद्धृत किया जा सकता है "..." or '...'. जीवीपीआर
C++ टिप्पणियों के साथ-साथ cpp-प्रकार की टिप्पणियाँ भी स्वीकार करता है। उत्तरार्द्ध के लिए, यदि कोई पंक्ति शुरू होती है
एक '#' वर्ण, शेष पंक्ति को अनदेखा कर दिया जाता है।

एक स्टेटमेंट एक फ़ंक्शन, एक वेरिएबल या एक ऐरे, या एक निष्पादन योग्य की घोषणा हो सकता है
कथन। घोषणाओं के लिए, एक ही गुंजाइश है. सरणी घोषणाओं का रूप इस प्रकार है:

टाइप सरणी [ type0 ]

जहां type0 वैकल्पिक है. यदि इसकी आपूर्ति की जाती है, तो पार्सर उस सभी सरणी को लागू करेगा
सबस्क्रिप्ट में निर्दिष्ट प्रकार होता है। यदि इसकी आपूर्ति नहीं की गई तो सभी प्रकार की वस्तुएं हो सकती हैं
सबस्क्रिप्ट के रूप में उपयोग किया जाता है। C की तरह, वेरिएबल्स और ऐरे को घोषित किया जाना चाहिए। विशेष रूप से, ए
अघोषित चर की व्याख्या किसी नोड, किनारे या की विशेषता के नाम के रूप में की जाएगी
संदर्भ के आधार पर ग्राफ़।

निष्पादन योग्य कथन निम्नलिखित में से एक हो सकते हैं:

{ [ कथन ... ] }
अभिव्यक्ति // सामान्यतः था = अभिव्यक्ति
अगर ( अभिव्यक्ति ) कथन [ अन्य कथन ]
के लिये( अभिव्यक्ति ; अभिव्यक्ति ; अभिव्यक्ति ) कथन
के लिये( सरणी [ था ]) कथन
forr( सरणी [ था ]) कथन
जबकि ( अभिव्यक्ति ) कथन
स्विच ( अभिव्यक्ति ) मामला बयान
तोड़ना [ अभिव्यक्ति ]
जारी रखने के [ अभिव्यक्ति ]
वापसी [ अभिव्यक्ति ]
कोष्ठक में आइटम वैकल्पिक हैं.

के दूसरे रूप में एसटी बयान और forr कथन, चर था इसके लिए सेट है
प्रत्येक मान को निर्दिष्ट सरणी में एक सूचकांक के रूप में उपयोग किया जाता है और फिर संबद्ध किया जाता है कथन is
मूल्यांकन किया गया। संख्यात्मक और स्ट्रिंग सूचकांकों के लिए, सूचकांक बढ़ते हुए लौटाए जाते हैं
(घटता हुआ) संख्यात्मक या शब्दकोषीय क्रम एसटी (forr, क्रमश)। इसका उपयोग किया जा सकता है
छँटाई के लिए.

फ़ंक्शन परिभाषाएँ केवल इसमें दिखाई दे सकती हैं शुरू खंड।

अभिव्यक्तियों में सामान्य C अभिव्यक्तियाँ शामिल हैं। स्ट्रिंग तुलना का उपयोग करना == और != इलाज करें
नियमित अभिव्यक्ति मिलान के प्रयोजन के लिए एक पैटर्न के रूप में दाहिने हाथ का ऑपरेंड। पैटर्न्स
उपयोग क्ष(1) फ़ाइल मिलान पैटर्न सिंटैक्स। (सरल स्ट्रिंग समानता के लिए, का उपयोग करें स्ट्रैम्प
समारोह.

जीवीपीआर किसी अभिव्यक्ति को स्ट्रिंग या संख्यात्मक मान के रूप में उपयुक्त के रूप में उपयोग करने का प्रयास किया जाएगा। दोनों
यदि संभव हो तो सी-लाइक कास्ट और फ़ंक्शन टेम्प्लेट रूपांतरण करने का कारण बनेंगे।

ग्राफ़िकल प्रकार की अभिव्यक्तियाँ (अर्थात्, ग्राफ_टी, नोड_टी, किनारा_टी, obj_t) का अनुसरण किया जा सकता है
फ़ील्ड संदर्भ के रूप में .नाम. परिणामी मान विशेषता का मान है
नामित नाम दी गई वस्तु का. इसके अतिरिक्त, कुछ सन्दर्भों में अघोषित,
असंशोधित पहचानकर्ता को एक विशेषता नाम माना जाता है। विशेष रूप से, ऐसे पहचानकर्ता
क्रमशः, वर्तमान नोड या किनारे की विशेषताओं को निरूपित करें N और E खंड, और
में वर्तमान ग्राफ BEG_G और END_जी खंड।

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

सिर : नोड_टी
एक किनारे का सिर.

पूंछ : नोड_टी
एक किनारे की पूँछ.

नाम : स्ट्रिंग
किसी किनारे, नोड या ग्राफ़ का नाम। एक किनारे के नाम का रूप है "<tail‐
नाम>[]", कहाँ पे है "->"या"--" इस पर निर्भर करते हुए
ग्राफ़ निर्देशित है या नहीं. कोष्ठक भाग [] केवल तभी प्रकट होता है जब
एज में एक गैर-तुच्छ कुंजी है।

डिग्री : int
एक नोड की डिग्री.

आउटडिग्री : int
एक नोड की आउटडिग्री.

हद : int
एक नोड की डिग्री.

जड़ : ग्राफ_टी
किसी वस्तु का मूल ग्राफ़। मूल ग्राफ का मूल स्वयं होता है।

माता - पिता : ग्राफ_टी
एक सबग्राफ का मूल ग्राफ़। रूट ग्राफ़ का जनक है नल

n_किनारे : int
ग्राफ़ में किनारों की संख्या

n_nodes : int
ग्राफ़ में नोड्स की संख्या

निर्देशित : int
यदि ग्राफ़ निर्देशित है तो सत्य (गैर-शून्य)।

कठोर : int
यदि ग्राफ़ सख्त है तो सत्य (गैर-शून्य)।

निर्मित कार्य

निम्नलिखित फ़ंक्शन अंतर्निहित हैं जीवीपीआर. वे फ़ंक्शन ग्राफ़ के संदर्भ लौटाते हैं
वस्तुएँ लौट आती हैं नल असफलता की स्थिति में.

रेखाचित्र और subgraph
ग्राफ(s : स्ट्रिंग, t : स्ट्रिंग): ग्राफ_टी
एक ग्राफ़ बनाता है जिसका नाम है s और जिसका प्रकार स्ट्रिंग द्वारा निर्दिष्ट है t.
केस, किरदारों को नजरअंदाज करना U, D, S, N व्याख्या अप्रत्यक्ष है,
क्रमशः निर्देशित, सख्त और गैर-सख्त। अगर t खाली है, एक निर्देशित, गैर-
सख्त ग्राफ उत्पन्न होता है।

उपजी(g : ग्राफ_टी, s : स्ट्रिंग): ग्राफ_टी
ग्राफ़ में एक सबग्राफ़ बनाता है g नाम के साथ s. यदि सबग्राफ़ पहले से मौजूद है, तो यह मौजूद है
लौटा हुआ।

isSubg(g : ग्राफ_टी, s : स्ट्रिंग): ग्राफ_टी
ग्राफ़ में सबग्राफ लौटाता है g नाम के साथ s, यदि यह मौजूद है, या नल अन्यथा।

fstsubg(g : ग्राफ_टी): ग्राफ_टी
ग्राफ़ में पहला सबग्राफ लौटाता है gया, नल यदि कोई मौजूद नहीं है.

nxtsubg(sg : ग्राफ_टी): ग्राफ_टी
इसके बाद अगला सबग्राफ लौटाता है sgया, नल.

प्रत्यक्ष है(g : ग्राफ_टी): int
सत्य लौटाता है यदि और केवल यदि g निर्देश दिया गया है।

सख्त है(g : ग्राफ_टी): int
सत्य लौटाता है यदि और केवल यदि g सख्त है.

nNodes(g : ग्राफ_टी): int
में नोड्स की संख्या लौटाता है g.

nEdges(g : ग्राफ_टी): int
किनारों की संख्या लौटाता है g.

नोड्स
नोड(sg : ग्राफ_टी, s : स्ट्रिंग): नोड_टी
ग्राफ़ में एक नोड बनाता है g नाम का s. यदि ऐसा कोई नोड पहले से मौजूद है, तो इसे वापस कर दिया जाता है।

उपनोड(sg : ग्राफ_टी, n : नोड_टी): नोड_टी
नोड सम्मिलित करता है n सबग्राफ में g. नोड लौटाता है.

fstnode(g : ग्राफ_टी): नोड_टी
ग्राफ़ में पहला नोड लौटाता है gया, नल यदि कोई मौजूद नहीं है.

nxtnode(n : नोड_टी): नोड_टी
के बाद अगला नोड लौटाता है n मूल ग्राफ़ में, या नल.

nxtnode_sg(sg : ग्राफ_टी, n : नोड_टी): नोड_टी
के बाद अगला नोड लौटाता है n in sgया, नल.

isNode(sg : ग्राफ_टी, s : स्ट्रिंग): नोड_टी
(उप) ग्राफ़ में एक नोड की तलाश करता है sg नाम का s. यदि ऐसा कोई नोड मौजूद है, तो इसे वापस कर दिया जाता है।
अन्यथा, नल वापस आ गया है

सबनोड है(sg : ग्राफ_टी, n : नोड_टी): int
यदि नोड गैर-शून्य लौटाता है n (उप)ग्राफ़ में है sg, या अन्यथा शून्य.

inडिग्रीऑफ़(sg : ग्राफ_टी, n : नोड_टी): int
नोड की डिग्री लौटाता है n (उप) ग्राफ़ में sg.

आउटडिग्रीऑफ़(sg : ग्राफ_टी, n : नोड_टी): int
नोड की आउटडिग्री लौटाता है n (उप) ग्राफ़ में sg.

की डिग्री(sg : ग्राफ_टी, n : नोड_टी): int
नोड की डिग्री लौटाता है n (उप) ग्राफ़ में sg.

किनारों
धार(t : नोड_टी, h : नोड_टी, s : स्ट्रिंग): किनारा_टी
टेल नोड के साथ एक किनारा बनाता है t, हेड नोड h और नाम s मूल ग्राफ़ में. यदि
ग्राफ अप्रत्यक्ष है, हेड और टेल नोड्स के बीच अंतर महत्वहीन है।
यदि ऐसी कोई बढ़त पहले से मौजूद है, तो इसे वापस कर दिया जाता है।

किनारा_एसजी(sg : ग्राफ_टी, t : नोड_टी, h : नोड_टी, s : स्ट्रिंग): किनारा_टी
टेल नोड के साथ एक किनारा बनाता है t, हेड नोड h और नाम s (उप) ग्राफ़ में sg (और सभी
मूल ग्राफ़)। यदि ग्राफ अप्रत्यक्ष है, तो हेड और टेल के बीच का अंतर
नोड्स महत्वहीन है. यदि ऐसी कोई बढ़त पहले से मौजूद है, तो इसे वापस कर दिया जाता है।

उपधार(g : ग्राफ_टी, e : किनारा_टी): किनारा_टी
किनारा डालता है e सबग्राफ में g. किनारा लौटाता है.

एज है(t : नोड_टी, h : नोड_टी, s : स्ट्रिंग): किनारा_टी
टेल नोड के साथ एक किनारे की तलाश करता है t, हेड नोड h और नाम s. यदि ग्राफ है
अप्रत्यक्ष, सिर और पूंछ नोड्स के बीच अंतर महत्वहीन है। यदि ऐसा कोई
किनारा मौजूद है, यह वापस आ गया है। अन्यथा, नल वापस आ गया है

isEdge_sg(sg : ग्राफ_टी, t : नोड_टी, h : नोड_टी, s : स्ट्रिंग): किनारा_टी
टेल नोड के साथ एक किनारे की तलाश करता है t, हेड नोड h और नाम s (उप) ग्राफ़ में sg। अगर
ग्राफ अप्रत्यक्ष है, हेड और टेल नोड्स के बीच अंतर महत्वहीन है।
यदि ऐसा कोई किनारा मौजूद है, तो इसे वापस कर दिया जाता है। अन्यथा, नल वापस आ गया है

सबबेज है(g : ग्राफ_टी, e : किनारा_टी): int
यदि किनारा है तो गैर-शून्य लौटाता है e (उप)ग्राफ़ में है sg, या अन्यथा शून्य.

fstout(n : नोड_टी): किनारा_टी
नोड का पहला आउटेज लौटाता है n मूल ग्राफ़ में.

fstout_sg(sg : ग्राफ_टी, n : नोड_टी): किनारा_टी
नोड का पहला आउटेज लौटाता है n (उप) ग्राफ़ में sg.

अगला(e : किनारा_टी): किनारा_टी
इसके बाद अगला आउटेज लौटाता है e मूल ग्राफ़ में.

nxtout_sg(sg : ग्राफ_टी, e : किनारा_टी): किनारा_टी
इसके बाद अगला आउटेज लौटाता है e ग्राफ में sg.

fstin(n : नोड_टी): किनारा_टी
नोड का पहला किनारा लौटाता है n मूल ग्राफ़ में.

fstin_sg(sg : ग्राफ_टी, n : नोड_टी): किनारा_टी
नोड का पहला किनारा लौटाता है n ग्राफ में sg.

अगला(e : किनारा_टी): किनारा_टी
के बाद अगला इनएज लौटाता है e मूल ग्राफ़ में.

nxtin_sg(sg : ग्राफ_टी, e : किनारा_टी): किनारा_टी
के बाद अगला इनएज लौटाता है e ग्राफ में sg.

fstedge(n : नोड_टी): किनारा_टी
नोड का पहला किनारा लौटाता है n मूल ग्राफ़ में.

fstedge_sg(sg : ग्राफ_टी, n : नोड_टी): किनारा_टी
नोड का पहला किनारा लौटाता है n ग्राफ में sg.

nxtedge(e : किनारा_टी, नोड_टी): किनारा_टी
के बाद अगला किनारा लौटाता है e मूल ग्राफ़ में.

nxtedge_sg(sg : ग्राफ_टी, e : किनारा_टी, नोड_टी): किनारा_टी
के बाद अगला किनारा लौटाता है e ग्राफ़ में sg.

ऑप(e : किनारा_टी, नोड_टी): नोड_टी
किनारे पर नोड लौटाता है e बराबर नही है n. यदि शून्य लौटाता है n का नोड नहीं है
e. उपयोग करते समय यह उपयोगी हो सकता है fstedge और nxtedge के पड़ोसियों की गणना करना
n.

ग्राफ मैं / हे
लिखना(g : ग्राफ_टी): शून्य
प्रिंट g आउटपुट स्ट्रीम पर डॉट प्रारूप में।

लिखोजी(g : ग्राफ_टी, fname : स्ट्रिंग): शून्य
प्रिंट g फ़ाइल में डॉट प्रारूप में fname.

fwriteG(g : ग्राफ_टी, fd : int): शून्य
प्रिंट g पूर्णांक द्वारा निरूपित खुली स्ट्रीम पर डॉट प्रारूप में fd.

पढ़ेंजी(fname : स्ट्रिंग): ग्राफ_टी
फ़ाइल से पढ़ा गया ग्राफ़ लौटाता है fname. ग्राफ़ डॉट प्रारूप में होना चाहिए. अगर कोई नहीं
ग्राफ पढ़ा जा सकता है, नल वापस आ गया है

फ़्रेडजी(fd : int): ग्राफ_टी
खुली स्ट्रीम से पढ़ा गया अगला ग्राफ़ लौटाता है fd. रिटर्न नल फ़ाइल के अंत में.

ग्राफ मिश्रण
हटाना(g : ग्राफ_टी, x : obj_t): शून्य
ऑब्जेक्ट हटा देता है x ग्राफ से g. अगर g is नल, फ़ंक्शन के रूट ग्राफ़ का उपयोग करता है
x. अगर x एक ग्राफ़ या सबग्राफ़ है, यह तब तक बंद रहता है जब तक x लॉक किया गया है।

में है(g : ग्राफ_टी, x : obj_t): int
यदि सत्य लौटाता है x सबग्राफ में है g.

क्लोनजी(g : ग्राफ_टी, s : स्ट्रिंग): ग्राफ_टी
ग्राफ़ का क्लोन बनाता है g के नाम के साथ s. अगर s "" है, बनाए गए ग्राफ़ में है
जैसा ही नाम g.

क्लोन(g : ग्राफ_टी, x : obj_t): obj_t
वस्तु का क्लोन बनाता है x ग्राफ में g. विशेष रूप से, नई वस्तु में वही है
मूल वस्तु के रूप में नाम/मूल्य विशेषताएँ और संरचना। यदि किसी वस्तु के साथ
जैसी ही कुंजी x पहले से मौजूद है, इसकी विशेषताएँ इनके गुणों से आच्छादित हैं x और
ऑब्जेक्ट वापस आ गया है. यदि एक किनारे को क्लोन किया जाता है, तो दोनों समापन बिंदु परोक्ष रूप से क्लोन किए जाते हैं।
यदि कोई ग्राफ क्लोन किया जाता है, तो सभी नोड्स, किनारों और सबग्राफ को अंतर्निहित रूप से क्लोन किया जाता है। अगर x
एक ग्राफ़ है, g हो सकता है नल, जिस स्थिति में क्लोन किया गया ऑब्जेक्ट एक नया रूट होगा
ग्राफ. इस मामले में, कॉल के बराबर है क्लोनजी(x,"").

प्रतिलिपि(g : ग्राफ_टी, x : obj_t): obj_t
ऑब्जेक्ट की एक प्रति बनाता है x ग्राफ में g, जहां नई वस्तु का नाम/मान समान है
मूल वस्तु के रूप में विशेषताएँ। यदि कोई ऑब्जेक्ट समान कुंजी के साथ है x पहले ही
अस्तित्व में है, इसकी विशेषताएँ इनके गुणों से आच्छादित हैं x और वस्तु वापस आ जाती है। टिप्पणी
कि यह एक उथली प्रति है. अगर x एक ग्राफ है, इसका कोई नोड, किनारा या सबग्राफ नहीं है
नए ग्राफ़ में कॉपी कर दिए जाते हैं. अगर x एक किनारा है, समापनबिंदु यदि बनाए जाते हैं
आवश्यक है, लेकिन उनका क्लोन नहीं बनाया गया है। अगर x एक ग्राफ़ है, g हो सकता है नल, कौनसे मामलेमें
क्लोन किया गया ऑब्जेक्ट एक नया रूट ग्राफ़ होगा।

कॉपीए(" : obj_t, TGT : obj_t): int
ऑब्जेक्ट की विशेषताओं की प्रतिलिपि बनाता है " वस्तु के लिए TGT, किसी भी विशेषता मान को अधिलेखित करना
TGT प्रारंभ में हो सकता है.

प्रेरित करना(g : ग्राफ_टी): शून्य
फैली g इसके रूट ग्राफ़ में इसके नोड-प्रेरित सबग्राफ़ विस्तार के लिए।

hasAttr(" : obj_t, नाम : स्ट्रिंग): int
यदि ऑब्जेक्ट गैर-शून्य लौटाता है " एक विशेषता है जिसका नाम है नाम. यह 0 लौटाता है
अन्यथा।

isAttr(g : ग्राफ_टी, तरह : स्ट्रिंग, नाम : स्ट्रिंग): int
यदि कोई विशेषता है तो गैर-शून्य लौटाता है नाम में परिभाषित किया गया है g की वस्तुओं के लिए
दी तरह. नोड्स, किनारों और ग्राफ़ के लिए, तरह "एन", "ई", और "जी" होना चाहिए,
क्रमश। अन्यथा यह 0 लौटाता है।

एगेट(" : obj_t, नाम : स्ट्रिंग): स्ट्रिंग
विशेषता का मान लौटाता है नाम वस्तु में ". यह उन मामलों के लिए उपयोगी है
कब नाम "हेड" या "रूट" जैसे कीवर्ड में से किसी एक के साथ विरोध। यदि
ग्राफ़ में विशेषता घोषित नहीं की गई है, फ़ंक्शन इसे प्रारंभ करेगा
"" का एक डिफ़ॉल्ट मान। इससे बचने के लिए इसका इस्तेमाल करना चाहिए hasAttr or isAttr समारोह
यह जाँचने के लिए कि विशेषता मौजूद है।

एक सेट(" : obj_t, नाम : स्ट्रिंग, मूल्य : स्ट्रिंग): int
विशेषता का मान निर्धारित करता है नाम वस्तु में " सेवा मेरे मूल्य. सफलता पर 0 लौटाता है,
विफलता पर गैर-शून्य. देखना एगेट ऊपर।

getDflt(g : ग्राफ_टी, तरह : स्ट्रिंग, नाम : स्ट्रिंग): स्ट्रिंग
विशेषता का डिफ़ॉल्ट मान लौटाता है नाम वस्तुओं में g दिए गए का तरह. के लिए
नोड्स, किनारे और ग्राफ़, तरह क्रमशः "एन", "ई", और "जी" होना चाहिए। यदि
ग्राफ़ में विशेषता घोषित नहीं की गई है, फ़ंक्शन इसे प्रारंभ करेगा
"" का एक डिफ़ॉल्ट मान। इससे बचने के लिए इसका इस्तेमाल करना चाहिए isAttr जांचने का कार्य
वह विशेषता मौजूद है.

setDflt(g : ग्राफ_टी, तरह : स्ट्रिंग, नाम : स्ट्रिंग, मूल्य : स्ट्रिंग): int
विशेषता का डिफ़ॉल्ट मान सेट करता है नाम सेवा मेरे मूल्य वस्तुओं में g दिए गए का
तरह. नोड्स, किनारों और ग्राफ़ के लिए, तरह क्रमशः "एन", "ई", और "जी" होना चाहिए।
सफलता पर 0, विफलता पर गैर-शून्य लौटाता है। देखना getDflt ऊपर।

fstAttr(g : ग्राफ_टी, तरह : स्ट्रिंग): स्ट्रिंग
वस्तुओं की पहली विशेषता का नाम लौटाता है g दिए गए का तरह. के लिए
नोड्स, किनारे और ग्राफ़, तरह क्रमशः "एन", "ई", और "जी" होना चाहिए। अगर वहाँ
कोई विशेषताएँ नहीं हैं, स्ट्रिंग "" लौटा दी गई है।

nxtAttr(g : ग्राफ_टी, तरह : स्ट्रिंग, नाम : स्ट्रिंग): स्ट्रिंग
वस्तुओं की अगली विशेषता का नाम लौटाता है g दिए गए का तरह के बाद
गुण नाम. तर्क नाम किसी मौजूदा विशेषता का नाम होना चाहिए; यह
आम तौर पर पिछली कॉल का रिटर्न मान होगा fstAttr or nxtAttr. के लिए
नोड्स, किनारे और ग्राफ़, तरह क्रमशः "एन", "ई", और "जी" होना चाहिए। अगर वहाँ
कोई विशेषता नहीं बची है, स्ट्रिंग "" लौटा दी गई है।

compOf(g : ग्राफ_टी, n : नोड_टी): ग्राफ_टी
ग्राफ़ का कनेक्टेड घटक लौटाता है g नोड युक्त n, के उपसमूह के रूप में
g. सबग्राफ में केवल नोड्स होते हैं। कोई भी प्रयोग कर सकता है प्रेरित करना किनारों को जोड़ने के लिए.
फ़ंक्शन विफल हो जाता है और वापस आ जाता है नल if n इसमें नहीं है g. कनेक्टिविटी पर आधारित है
का अंतर्निहित अप्रत्यक्ष ग्राफ़ g.

एक प्रकार का(obj : obj_t): स्ट्रिंग
के प्रकार का संकेत देता है obj. नोड्स, किनारों और ग्राफ़ के लिए, यह वापस आता है
क्रमशः "एन", "ई", और "जी"।

ताला(g : ग्राफ_टी, v : int): int
रूट ग्राफ़ पर ग्राफ़ लॉकिंग लागू करता है। यदि पूर्णांक v सकारात्मक है, ग्राफ है
सेट करें ताकि भविष्य में कॉल आए हटाना कोई तत्काल प्रभाव नहीं पड़ता. अगर v शून्य है,
ग्राफ़ अनलॉक है. यदि ग्राफ़ के रहते हुए उसे हटाने के लिए कोई कॉल आया हो
लॉक किया गया, ग्राफ़ बंद है. अगर v नकारात्मक है, कुछ भी नहीं किया गया है। सभी मामलों में,
पिछला लॉक मान वापस कर दिया गया है।

स्ट्रिंग्स
sprintf(fmt : स्ट्रिंग, ...): स्ट्रिंग
अभिव्यक्ति के मानों को फ़ॉर्मेट करने से उत्पन्न स्ट्रिंग लौटाता है
के बाद घटित हो रहा है fmt के अनुसार printf(3) प्रारूप fmt

gsub(str : स्ट्रिंग, थपथपाना : स्ट्रिंग): स्ट्रिंग

gsub(str : स्ट्रिंग, थपथपाना : स्ट्रिंग, आरईपीएल : स्ट्रिंग): स्ट्रिंग
रिटर्न str सभी सबस्ट्रिंग मिलान के साथ थपथपाना हटा दिया गया या प्रतिस्थापित कर दिया गया आरईपीएल,
क्रमशः.

नीचे(str : स्ट्रिंग, थपथपाना : स्ट्रिंग): स्ट्रिंग

नीचे(str : स्ट्रिंग, थपथपाना : स्ट्रिंग, आरईपीएल : स्ट्रिंग): स्ट्रिंग
रिटर्न str सबसे बाईं सबस्ट्रिंग के मिलान के साथ थपथपाना हटा दिया गया या प्रतिस्थापित कर दिया गया आरईपीएल,
क्रमश। आरंभ और अंत में '^' और '$' वर्णों का उपयोग किया जा सकता है,
क्रमशः, का थपथपाना पैटर्न को आरंभ या अंत में स्थापित करना str.

substr(str : स्ट्रिंग, IDX : int): स्ट्रिंग

substr(str : स्ट्रिंग, IDX : int, लेन : int): स्ट्रिंग
का सबस्ट्रिंग लौटाता है str स्थिति से शुरू IDX स्ट्रिंग के अंत तक या
लंबाई की लेन, क्रमश। अनुक्रमण 0 से प्रारंभ होता है। यदि IDX नकारात्मक है या IDX is
की लम्बाई से अधिक str, एक घातक त्रुटि उत्पन्न होती है। इसी तरह, दूसरे में
मामला, यदि लेन नकारात्मक है या IDX + लेन की लंबाई से अधिक है str, एक घातक
त्रुटि होती है।

स्ट्रैम्प(s1 : स्ट्रिंग, s2 : स्ट्रिंग): int
मानक C फ़ंक्शन प्रदान करता है स्ट्रैम्प(3).

लंबाई(s : स्ट्रिंग): int
स्ट्रिंग की लंबाई लौटाता है s.

अनुक्रमणिका(s : स्ट्रिंग, t : स्ट्रिंग): int

रिनडेक्स(s : स्ट्रिंग, t : स्ट्रिंग): int
स्ट्रिंग में वर्ण का सूचकांक लौटाता है s जहां सबसे बाईं (सबसे दाहिनी) प्रतिलिपि है
स्ट्रिंग का t पाया जा सकता है, या -1 यदि t का उपस्ट्रिंग नहीं है s.

मैच(s : स्ट्रिंग, p : स्ट्रिंग): int
स्ट्रिंग में वर्ण का सूचकांक लौटाता है s जहां पैटर्न का सबसे बायां मिलान है
p पाया जा सकता है, या -1 यदि कोई सबस्ट्रिंग नहीं है s मैच p.

टॉपर(s : स्ट्रिंग): स्ट्रिंग
का एक संस्करण लौटाता है s वर्णमाला वर्णों को अपरकेस में परिवर्तित किया गया।

कम करना(s : स्ट्रिंग): स्ट्रिंग
का एक संस्करण लौटाता है s वर्णमाला वर्णों को लोअर-केस में परिवर्तित किया गया।

कैनन(s : स्ट्रिंग): स्ट्रिंग
का एक संस्करण लौटाता है s डॉट फ़ाइल में पहचानकर्ता के रूप में उपयोग करने के लिए उपयुक्त।

HTML(g : ग्राफ_टी, s : स्ट्रिंग): स्ट्रिंग
का ``जादुई'' संस्करण लौटाता है s एक HTML स्ट्रिंग के रूप में। इसका आमतौर पर उपयोग किया जाएगा
ग्राफ़ ऑब्जेक्ट में HTML जैसा लेबल संलग्न करें। ध्यान दें कि लौटी हुई स्ट्रिंग अंदर रहती है
g. खास तौर पर यह कब मुक्त होगा g बंद है, और HTML स्ट्रिंग के रूप में कार्य करने के लिए,
इसका उपयोग किसी वस्तु के साथ करना होगा g. इसके अलावा, ध्यान दें कि कोण ब्रैकेट
उद्धरण का हिस्सा नहीं होना चाहिए s. इन्हें जोड़ा जाएगा यदि g ठोस डॉट में लिखा है
प्रारूप.

ishtml(s : स्ट्रिंग): int
यदि और केवल यदि, तो गैर-शून्य लौटाता है s एक HTML स्ट्रिंग है.

xOf(s : स्ट्रिंग): स्ट्रिंग
स्ट्रिंग लौटाता है"x" अगर s रूप है"x,y", दोनों कहाँ x और y संख्यात्मक हैं.

आप का(s : स्ट्रिंग): स्ट्रिंग
स्ट्रिंग लौटाता है"y" अगर s रूप है"x,y", दोनों कहाँ x और y संख्यात्मक हैं.

llका(s : स्ट्रिंग): स्ट्रिंग
स्ट्रिंग लौटाता है"LLX,lly" अगर s रूप है"LLX,lly,उरक्स,URY", जहां सभी LLX,
lly, उरक्स, तथा URY संख्यात्मक हैं.

urOf(s)
आपका(s : स्ट्रिंग): स्ट्रिंग स्ट्रिंग लौटाता है"उरक्स,URY" अगर s का रूप है
"LLX,lly,उरक्स,URY", जहां सभी LLX, lly, उरक्स, तथा URY संख्यात्मक हैं.

sscanf(s : स्ट्रिंग, fmt : स्ट्रिंग, ...): int
स्ट्रिंग को स्कैन करता है s, के अनुसार मान निकालना sscanf(3) प्रारूप fmt।
मान निम्नलिखित पतों में संग्रहीत हैं fmt, प्रपत्र वाले पते &v,
जहां v सही प्रकार का कुछ घोषित चर है। आइटमों की संख्या लौटाता है
सफलतापूर्वक स्कैन किया गया.

विभाजित(s : स्ट्रिंग, आगमन : सरणी, सितम्बर : स्ट्रिंग): int

विभाजित(s : स्ट्रिंग, आगमन : सरणी): int

टोकन(s : स्ट्रिंग, आगमन : सरणी, सितम्बर : स्ट्रिंग): int

टोकन(s : स्ट्रिंग, आगमन : सरणी): int
RSI विभाजित फ़ंक्शन स्ट्रिंग को तोड़ता है s खेतों में, जबकि टोकन समारोह
स्ट्रिंग को टोकन में तोड़ता है। एक फ़ील्ड में सभी गैर-विभाजक वर्ण होते हैं
दो विभाजक वर्णों या स्ट्रिंग की शुरुआत या अंत के बीच। इस प्रकार, ए
फ़ील्ड खाली स्ट्रिंग हो सकती है. टोकन एक अधिकतम, गैर-रिक्त सबस्ट्रिंग है
एक विभाजक चरित्र युक्त. विभाजक वर्ण वे हैं जो इसमें दिए गए हैं
सितम्बर तर्क। अगर सितम्बर प्रदान नहीं किया गया है, डिफ़ॉल्ट मान "\t\n" है।
फ़ंक्शंस फ़ील्ड या टोकन की संख्या लौटाते हैं।

फ़ील्ड और टोकन तर्क सरणी में संग्रहीत हैं। सरणी होनी चाहिए स्ट्रिंग-
मूल्यवान और, यदि कोई सूचकांक प्रकार निर्दिष्ट है, तो यह अवश्य होना चाहिए int. प्रविष्टियाँ अनुक्रमित हैं
लगातार पूर्णांकों द्वारा, 0 से शुरू करके। सरणी में पहले से संग्रहीत कोई भी मान होगा
या तो ओवरराइट किया जाए, या फ़ंक्शन के वापस आने के बाद भी मौजूद रहे।

मैं / हे
छाप(...): शून्य
प्रिंट ( expr, ... ) बारी-बारी से प्रत्येक तर्क का एक स्ट्रिंग प्रतिनिधित्व प्रिंट करता है
stdout, उसके बाद एक नई पंक्ति।

printf(fmt : स्ट्रिंग, ...): int

printf(fd : int, fmt : स्ट्रिंग, ...): int
निम्नलिखित भावों के मानों को फ़ॉर्मेट करने से उत्पन्न स्ट्रिंग को प्रिंट करता है
fmt के अनुसार printf(3) प्रारूप fmt. सफलता पर 0 लौटाता है। डिफ़ॉल्ट रूप से, यह
पर प्रिंट करता है stdout. यदि वैकल्पिक पूर्णांक fd दिया गया है, आउटपुट पर लिखा है
ओपन स्ट्रीम के साथ जुड़ा हुआ है fd.

scanf(fmt : स्ट्रिंग, ...): int

scanf(fd : int, fmt : स्ट्रिंग, ...): int
के अनुसार इनपुट स्ट्रीम से मानों को स्कैन करता है scanf(3) प्रारूप fmt।
मान निम्नलिखित पतों में संग्रहीत हैं fmt, प्रपत्र वाले पते &v,
जहां v सही प्रकार का कुछ घोषित चर है। डिफ़ॉल्ट रूप से, यह से पढ़ता है
stdin. यदि वैकल्पिक पूर्णांक fd दिया गया है, इनपुट खुली स्ट्रीम से पढ़ा जाता है
के साथ जुड़े fd. सफलतापूर्वक स्कैन किए गए आइटमों की संख्या लौटाता है।

खुलाएफ(s : स्ट्रिंग, t : स्ट्रिंग): int
फ़ाइल खोलता है s I/O स्ट्रीम के रूप में। स्ट्रिंग तर्क t निर्दिष्ट करता है कि फ़ाइल कैसी है
खुल गया। तर्क C फ़ंक्शन के समान ही हैं फोपेन(3). यह एक लौटाता है
स्ट्रीम को दर्शाने वाला पूर्णांक, या त्रुटि पर -1।

हमेशा की तरह, स्ट्रीम 0, 1 और 2 पहले से ही खुले हैं stdin, stdout, तथा stderr,
क्रमश। तब से जीवीपीआर उपयोग कर सकते हैं stdin इनपुट ग्राफ़ को पढ़ने के लिए, उपयोगकर्ता को चाहिए
इस स्ट्रीम का उपयोग करने से बचें.

बंद करेंF(fd : int): int
पूर्णांक द्वारा निरूपित खुली धारा को बंद कर देता है fd. धाराएँ 0, 1 और 2 नहीं हो सकतीं
बंद किया हुआ। सफलता पर 0 लौटाता है।

पढ़ेंएल(fd : int): स्ट्रिंग
इनपुट स्ट्रीम से पढ़ी गई अगली पंक्ति लौटाता है fd. यह खाली स्ट्रिंग लौटाता है ""
फ़ाइल के अंत में. ध्यान दें कि न्यूलाइन कैरेक्टर लौटाई गई स्ट्रिंग में बचा हुआ है।

मठ
exp(d : डबल): डबल
ई को लौटाता है dवें शक्ति.

लॉग इन(d : डबल): डबल
का प्राकृतिक लॉग लौटाता है d.

sqrt(d : डबल): डबल
दोहरे का वर्गमूल लौटाता है d.

पॉव(d : डबल, x : डबल): डबल
रिटर्न d को उठाया xवें शक्ति.

गाड़ी(d : डबल): डबल
की कोज्या लौटाता है d.

पाप(d : डबल): डबल
की साइन लौटाता है d.

atan2(y : डबल, x : डबल): डबल
का आर्कटेन्जेंट लौटाता है y / x रेंज में -pi से pi तक।

न्यूनतम(y : डबल, x : डबल): डबल
का न्यूनतम लौटाता है y और x.

मैक्स(y : डबल, x : डबल): डबल
का अधिकतम लौटाता है y और x.

जोड़नेवाला Arrays
# आगमन : int
सरणी में तत्वों की संख्या लौटाता है आगमन.

IDX in आगमन : int
यदि सूचकांक के लिए कोई मान निर्धारित किया गया है तो 1 लौटाता है IDX सरणी में आगमन. यह 0 लौटाता है
अन्यथा।

सेट नहीं(v : सरणी, IDX): int
द्वारा अनुक्रमित आइटम को हटा देता है IDX. यदि आइटम मौजूद है तो यह 1 लौटाता है, अन्यथा 0 लौटाता है।

सेट नहीं(v : सरणी): शून्य
सरणी को पुनः प्रारंभ करता है।

कई तरह का
निकास(v : int): शून्य
का कारण बनता है जीवीपीआर निकास कोड के साथ बाहर निकलने के लिए v.

प्रणाली(सीएमडी : स्ट्रिंग): int
मानक C फ़ंक्शन प्रदान करता है प्रणाली(3). यह क्रियान्वित होता है सीएमडी उपयोगकर्ता के शेल में
वातावरण, और शेल की निकास स्थिति लौटाता है।

पंक्ति() : डबल
0 और 1 के बीच एक छद्म-यादृच्छिक दोहरा लौटाता है।

सरंड() : int

सरंड(v : int): int
यादृच्छिक संख्या जनरेटर के लिए एक बीज सेट करता है। वैकल्पिक तर्क बीज देता है;
यदि इसे छोड़ दिया जाए तो वर्तमान समय का उपयोग किया जाता है। पिछला बीज मूल्य वापस कर दिया जाता है।
सरंड किसी भी कॉल से पहले कॉल किया जाना चाहिए पंक्ति.

colorx(रंग : स्ट्रिंग, fmt : स्ट्रिंग): स्ट्रिंग
एक रंग को एक प्रारूप से दूसरे प्रारूप में अनुवादित करता है। रंग तर्क एक रंग होना चाहिए
मान्यता प्राप्त स्ट्रिंग अभ्यावेदन में से एक में। fmt मान इनमें से एक होना चाहिए
"आरजीबी", "आरजीबीए", "एचएसवी", या "एचएसवीए"। त्रुटि होने पर एक खाली स्ट्रिंग लौटा दी जाती है।

निर्मित चर

जीवीपीआर कुछ विशेष, अंतर्निहित चर प्रदान करता है, जिनके मान स्वचालित रूप से निर्धारित होते हैं
जीवीपीआर संदर्भ के आधार पर. जैसा कि उल्लेख किया गया है, उसके अलावा, उपयोगकर्ता अपने मूल्यों को संशोधित नहीं कर सकता है।

$ : obj_t
संदर्भ के आधार पर वर्तमान वस्तु (नोड, किनारा, ग्राफ़) को दर्शाता है। यह नहीं है
में उपलब्ध शुरू or अंत खंड।

$F : स्ट्रिंग
वर्तमान इनपुट फ़ाइल का नाम है.

$G : ग्राफ_टी
संसाधित किए जा रहे वर्तमान ग्राफ़ को दर्शाता है। यह में उपलब्ध नहीं है शुरू or अंत
खंड।

$एनजी : ग्राफ_टी
संसाधित होने वाले अगले ग्राफ़ को दर्शाता है। अगर $एनजी शून्य है, वर्तमान ग्राफ़ $G विश्व का सबसे लोकप्रिय एंव
अंतिम ग्राफ. ध्यान दें कि यदि इनपुट stdin से आता है, तो अंतिम ग्राफ़ नहीं हो सकता
इनपुट पाइप बंद होने तक निर्धारित किया जाता है। यह में उपलब्ध नहीं है शुरू or अंत
खंड, या यदि -n ध्वज का प्रयोग किया जाता है.

$O : ग्राफ_टी
आउटपुट ग्राफ़ को दर्शाता है। ग्राफ़ ट्रैवर्सल से पहले, इसे लक्ष्य के लिए प्रारंभ किया जाता है
ग्राफ. ट्रैवर्सल के बाद और कोई भी END_जी क्रियाएँ, यदि यह एक गैर-रिक्त ग्राफ़ को संदर्भित करती है,
वह ग्राफ़ आउटपुट स्ट्रीम पर मुद्रित होता है। यह केवल में मान्य है N, E और END_जी
खंड। आउटपुट ग्राफ़ उपयोगकर्ता द्वारा सेट किया जा सकता है।

$T : ग्राफ_टी
वर्तमान लक्ष्य ग्राफ़ को दर्शाता है। यह का एक उपसमूह है $G और केवल में उपलब्ध है
N, E और END_जी खंड।

$tgtनाम : स्ट्रिंग
लक्ष्य ग्राफ़ के नाम को दर्शाता है। डिफ़ॉल्ट रूप से, यह पर सेट है "gvpr_result". अगर
के निष्पादन के दौरान कई बार उपयोग किया गया जीवीपीआर, नाम के साथ जोड़ा जाएगा
पूर्णांक. यह वेरिएबल उपयोगकर्ता द्वारा सेट किया जा सकता है.

$tvroot : नोड_टी
(निर्देशित या अप्रत्यक्ष) गहराई-पहले या चौड़ाई- के लिए शुरुआती नोड को इंगित करता है
ग्राफ़ का पहला ट्रैवर्सल (cf. $tvtype नीचे)। डिफ़ॉल्ट मान है नल एसटी
प्रत्येक इनपुट ग्राफ़. दिए गए रूट पर ट्रैवर्सल के बाद, यदि का मान $tvroot
बदल गया है, एक नया ट्रैवर्सल नए मूल्य के साथ शुरू होगा $tvroot. इसके अलावा, सेट करें
$tvnext नीचे.

$tvnext : नोड_टी
(निर्देशित या अप्रत्यक्ष) गहराई के लिए अगले शुरुआती नोड को इंगित करता है-पहले या
चौड़ाई- ग्राफ़ का पहला ट्रैवर्सल (सीएफ)। $tvtype नीचे)। यदि कोई ट्रैवर्सल समाप्त हो जाता है
और $tvroot रीसेट नहीं किया गया है लेकिन $tvnext सेट किया गया है लेकिन उपयोग नहीं किया गया है, यह
नोड का उपयोग अगली पसंद के रूप में किया जाएगा $tvroot. डिफ़ॉल्ट मान है नल एसटी
प्रत्येक इनपुट ग्राफ़.

$tvedge : किनारा_टी
बीएफएस और डीएफएस ट्रैवर्सल के लिए, इसे करंट पर पहुंचने के लिए उपयोग किए जाने वाले किनारे पर सेट किया गया है
नोड या किनारा. ट्रैवर्सल की शुरुआत में, या अन्य ट्रैवर्सल प्रकारों के लिए,
मूल्य है नल.

$tvtype : tvtype_t
इंगित करता है कि कैसे जीवीपीआर एक ग्राफ़ पार करता है. यह केवल एक स्थिर मान ले सकता है
नीचे वर्णित उपसर्ग "TV_" के साथ। टीवी_फ्लैट डिफ़ॉल्ट है।

अंतर्निहित ग्राफ़ लाइब्रेरी में सीग्राफ(3), अप्रत्यक्ष ग्राफ़ में किनारे दिए गए हैं
मनमानी दिशा. इसका उपयोग ट्रैवर्सल के लिए किया जाता है, जैसे कि TV_fwd, आवश्यकता
निर्देशित किनारे.

एआरजीसी : int
द्वारा निर्दिष्ट तर्कों की संख्या को दर्शाता है -a आर्ग कमांड-लाइन तर्क.

एआरजीवी : स्ट्रिंग सरणी
द्वारा निर्दिष्ट तर्कों की सारणी को दर्शाता है -a आर्ग कमांड-लाइन तर्क।
iवां तर्क किसके द्वारा दिया गया है? एआरजीवी[i].

निर्मित स्थिरांक

इसके द्वारा परिभाषित कई प्रतीकात्मक स्थिरांक हैं जीवीपीआर.

नल : obj_t
एक शून्य वस्तु संदर्भ, 0 के बराबर।

टीवी_फ्लैट : tvtype_t
एक सरल, सपाट ट्रैवर्सल, जिसमें ग्राफ़ ऑब्जेक्ट को मनमाने ढंग से क्रम में देखा जाता है।

टीवी_ने : tvtype_t
एक ट्रैवर्सल जो पहले सभी नोड्स पर जाता है, फिर सभी किनारों पर।

टीवी_एन : tvtype_t
एक ट्रैवर्सल जो पहले सभी किनारों पर जाता है, फिर सभी नोड्स पर।

TV_dfs : tvtype_t
TV_postdfs : tvtype_t
TV_prepostdfs : tvtype_t
अंतर्निहित अप्रत्यक्ष पर गहराई-पहली खोज का उपयोग करके ग्राफ़ का ट्रैवर्सल
ग्राफ. ट्रैवर्सल करने के लिए, जीवीपीआर के मूल्य की जांच करेगा $tvroot. यदि यह है
वही मान जो पहले था (प्रारंभ में, पिछला मान आरंभ किया जाता है
सेवा मेरे नल.) जीवीपीआर बस कुछ अनविज़िट नोड की तलाश करेगा और उससे जुड़े हुए नोड का पता लगाएगा
अवयव। दूसरी ओर, यदि $tvroot बदल गया है, इसका जुड़ा घटक बदल जाएगा
यह मानते हुए कि पहले कभी इसका दौरा नहीं किया गया है या यदि किया गया है, तो दौरा किया जाना चाहिए $tvroot is नल,
ट्रैवर्सल रुक जाएगा. ध्यान दें कि उपयोग कर रहे हैं TV_dfs और $tvroot, बनाना संभव है
एक अनंत लूप.

डिफ़ॉल्ट रूप से, ट्रैवर्सल प्री-ऑर्डर में किया जाता है। यानी एक नोड पहले विजिट किया जाता है
इसके सभी अनदेखे किनारे। के लिए TV_postdfs, एक नोड के सभी अनदेखे किनारे हैं
नोड से पहले दौरा किया। के लिए TV_prepostdfs, एक नोड पर और से पहले दो बार दौरा किया जाता है
इसके सभी अनदेखे किनारों के बाद।

TV_fwd : tvtype_t
TV_postfwd : tvtype_t
TV_prepostfwd : tvtype_t
केवल निम्नलिखित ग्राफ़ पर गहराई-पहली खोज का उपयोग करके ग्राफ़ का ट्रैवर्सल
आगे की ओर चाप. ट्रैवर्सल के लिए जड़ों का चुनाव वैसा ही है जैसा कि वर्णित है
TV_dfs ऊपर। मुलाक़ात का अलग-अलग क्रम निर्दिष्ट किया गया है TV_fwd, TV_postfwd
और TV_prepostfwd अनुरूप ट्रैवर्सल द्वारा निर्दिष्ट के समान ही हैं
TV_dfs, TV_postdfs और TV_prepostdfs.

टीवी_रेव : tvtype_t
TV_postrev : tvtype_t
TV_prepostrev : tvtype_t
केवल निम्नलिखित ग्राफ़ पर गहराई-पहली खोज का उपयोग करके ग्राफ़ का ट्रैवर्सल
उलटा चाप. ट्रैवर्सल के लिए जड़ों का चुनाव वैसा ही है जैसा कि वर्णित है
TV_dfs ऊपर। मुलाक़ात का अलग-अलग क्रम निर्दिष्ट किया गया है टीवी_रेव, TV_postrev
और TV_prepostrev अनुरूप ट्रैवर्सल द्वारा निर्दिष्ट के समान ही हैं
TV_dfs, TV_postdfs और TV_prepostdfs.

टीवी_बीएफएस : tvtype_t
किनारे को अनदेखा करते हुए ग्राफ़ पर चौड़ाई-पहली खोज का उपयोग करके ग्राफ़ का ट्रैवर्सल
दिशानिर्देश. आइटम को देखें TV_dfs की भूमिका के लिए ऊपर $tvroot.

उदाहरण

जीवीपीआर -i 'एन[रंग==नीला']' फ़ाइल.gv

नीले रंग के साथ सभी नोड्स के नोड-प्रेरित सबग्राफ उत्पन्न करें।

जीवीपीआर -c 'एन[रंग==नीला']{रंग = "लाल"}' फ़ाइल.gv

सभी नीले नोड्स को लाल बनाएं।

शुरू { int n, e; int tot_n = 0; int टोट_ई = 0; }
BEG_G {
n = nNodes($G);
e = nEdges ($ जी);
printf ("%डी नोड्स %d किनारों %s\n", n, e, $जी.नाम);
tot_n += n;
टोट_ई += e;
}
अंत { printf ("%डी नोड्स %d किनारों कुल\n", tot_n, टोट_ई) }

कार्यक्रम का संस्करण gc.

जीवीपीआर -c ""

के बराबर nop.

BEG_G { ग्राफ_टी g = ग्राफ ("विलय", "एस"); }
E {
नोड_टी h = क्लोन(जी,$.हेड);
नोड_टी t = क्लोन(जी,$.पूंछ);
किनारा_टी e = किनारा(टी,एच,"");
ई.वजन = ई.वजन + 1;
}
END_जी { $O = g; }

इनपुट ग्राफ़ का एक सख्त संस्करण तैयार करता है, जहां एक किनारे का वजन विशेषता होती है
इंगित करता है कि इनपुट ग्राफ़ से किनारा कितने किनारों का प्रतिनिधित्व करता है।

शुरू {नोड_टी n; int डिग्री[]}
ई{डिग्री[सिर]++; डिग्री[पूंछ]++; }
END_जी {
एसटी (डिग्री[एन]) {
printf ("डिग्री[%s] = %d\n", n.नाम, डिग्री[एन]);
}
}

किनारों के साथ नोड्स की डिग्री की गणना करता है।

शुरू {
int i, मांगपत्र;
int देखा[स्ट्रिंग];
शून्य prind (इंट सीएनटी) {
एसटी (i = 0; i < सीएनटी; मैं++) printf (" ");
}
}
BEG_G {

$tvtype = TV_prepostfwd;
$tvroot = नोड($,ARGV[0]);
}
N {
if (देखा गया[$.नाम]) इंडेंट--;
अन्य {
prInd(इंडेंट);
छाप ($.नाम);
देखा[$.नाम] = 1;
इंडेंट++;
}
}

ग्राफ़ के गहराई-प्रथम ट्रैवर्सल को उस नोड से शुरू करता है जिसका नाम है
एआरजीवी [0], एक इंडेंटेड सूची के रूप में।

वातावरण

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

विंडोज़ सिस्टम पर, पिछले पैराग्राफ में ``कोलन'' को ``सेमीकोलन'' से बदलें।

onworks.net सेवाओं का उपयोग करके ऑनलाइन जीवीपीआर का उपयोग करें