gvpr - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

gvpr - ഗ്രാഫ് പാറ്റേൺ സ്കാനിംഗും പ്രോസസ്സിംഗ് ഭാഷയും

സിനോപ്സിസ്

gvpr [-icnqV?] [ -o ഔട്ട്ഫിൽ ] [ -a വാദിക്കുന്നു ] [ 'പ്രോഗ്' | -f പ്രൊഫൈൽ ] [ ഫയലുകൾ ]

വിവരണം

gvpr (മുമ്പ് അറിയപ്പെട്ടിരുന്നത് ജിപിആർ) പ്രചോദനം ഉൾക്കൊണ്ട ഒരു ഗ്രാഫ് സ്ട്രീം എഡിറ്ററാണ് ഉണരുക. ഇത് ഇൻപുട്ട് പകർത്തുന്നു
ഗ്രാഫുകൾ അതിന്റെ ഔട്ട്പുട്ടിലേക്ക്, ഒരുപക്ഷേ അവയുടെ ഘടനയും ആട്രിബ്യൂട്ടുകളും രൂപാന്തരപ്പെടുത്തി, പുതിയത് സൃഷ്ടിക്കുന്നു
ഗ്രാഫുകൾ, അല്ലെങ്കിൽ അനിയന്ത്രിതമായ വിവരങ്ങൾ അച്ചടിക്കുന്നു. ഗ്രാഫ് മോഡൽ നൽകിയത്
ലിബ്സിഗ്രാഫ്(3). പ്രത്യേകിച്ച്, gvpr ഡോട്ട് ഭാഷ ഉപയോഗിച്ച് ഗ്രാഫുകൾ വായിക്കുകയും എഴുതുകയും ചെയ്യുന്നു.

അടിസ്ഥാനപരമായി, gvpr സൂചിപ്പിച്ചിരിക്കുന്ന ഓരോ ഇൻപുട്ട് ഗ്രാഫിലും സഞ്ചരിക്കുന്നു $G, ഓരോ നോഡും അരികും സന്ദർശിക്കുന്നു,
ഇൻപുട്ട് പ്രോഗ്രാമിൽ നൽകിയിരിക്കുന്ന പ്രവചന-പ്രവർത്തന നിയമങ്ങളുമായി ഇത് പൊരുത്തപ്പെടുത്തുന്നു. നിയമങ്ങളാണ്
ക്രമത്തിൽ വിലയിരുത്തി. ശരി എന്ന് മൂല്യനിർണ്ണയം ചെയ്യുന്ന ഓരോ പ്രവചനത്തിനും, അനുബന്ധ പ്രവർത്തനം
നിർവഹിച്ചു. യാത്രാവേളയിൽ, സന്ദർശിക്കുന്ന നിലവിലെ നോഡ് അല്ലെങ്കിൽ എഡ്ജ് സൂചിപ്പിക്കുന്നത് $.

ഓരോ ഇൻപുട്ട് ഗ്രാഫിനും, ഒരു ടാർഗെറ്റ് സബ്ഗ്രാഫ് ഉണ്ട്, ഇത് സൂചിപ്പിച്ചിരിക്കുന്നു $T, തുടക്കത്തിൽ ശൂന്യവും ഉപയോഗിച്ചു
തിരഞ്ഞെടുത്ത എന്റിറ്റികളും ഒരു ഔട്ട്പുട്ട് ഗ്രാഫും ശേഖരിക്കാൻ, $O, അന്തിമ പ്രോസസ്സിംഗിനും തുടർന്ന് ഉപയോഗിക്കും
ഔട്ട്പുട്ടിലേക്ക് എഴുതിയിരിക്കുന്നു. സ്ഥിരസ്ഥിതിയായി, ഔട്ട്പുട്ട് ഗ്രാഫ് ടാർഗെറ്റ് ഗ്രാഫ് ആണ്. ഔട്ട്പുട്ട് ഗ്രാഫ്
പ്രോഗ്രാമിൽ അല്ലെങ്കിൽ, പരിമിതമായ അർത്ഥത്തിൽ, കമാൻഡ് ലൈനിൽ സജ്ജമാക്കാൻ കഴിയും.

ഓപ്ഷനുകൾ

ഇനിപ്പറയുന്ന ഓപ്ഷനുകൾ പിന്തുണയ്ക്കുന്നു:

-a വാദിക്കുന്നു
ചരട് വാദിക്കുന്നു വൈറ്റ്‌സ്‌പെയ്‌സ്-വേർതിരിക്കപ്പെട്ട ടോക്കണുകളായി വിഭജിച്ചിരിക്കുന്നു, വ്യക്തിയുമായി
എന്നതിൽ സ്ട്രിംഗുകളായി ടോക്കണുകൾ ലഭ്യമാണ് gvpr പ്രോഗ്രാം ആയി ARGV[0],...,ARGV[ARGC-1].
ഒറ്റ അല്ലെങ്കിൽ ഇരട്ട ഉദ്ധരണി ഉപസ്‌ട്രിംഗുകൾക്കുള്ളിലെ വൈറ്റ്‌സ്‌പെയ്‌സ് പ്രതീകങ്ങൾ, അല്ലെങ്കിൽ അതിന് മുമ്പുള്ള a
ബാക്ക്സ്ലാഷ്, സെപ്പറേറ്ററുകളായി അവഗണിക്കപ്പെടുന്നു. പൊതുവേ, ഒരു ബാക്ക്സ്ലാഷ് പ്രതീകം ഓഫാകുന്നു
ഇനിപ്പറയുന്ന പ്രതീകത്തിന്റെ ഏതെങ്കിലും പ്രത്യേക അർത്ഥം. ടോക്കണുകൾ ഉരുത്തിരിഞ്ഞത് ശ്രദ്ധിക്കുക
ഒന്നിലധികം -a പതാകകൾ ഘടിപ്പിച്ചിരിക്കുന്നു.

-c ഔട്ട്പുട്ട് ഗ്രാഫായി ഉറവിട ഗ്രാഫ് ഉപയോഗിക്കുക.

-i ഇതിന്റെ പശ്ചാത്തലത്തിൽ ഔട്ട്‌പുട്ട് ഗ്രാഫിന്റെ നോഡ്-ഇൻഡ്യൂസ്‌ഡ് സബ്‌ഗ്രാഫ് വിപുലീകരണം നേടുക
അതിന്റെ റൂട്ട് ഗ്രാഫ്.

-o ഔട്ട്ഫിൽ
നിർദ്ദിഷ്ട ഫയലിലേക്ക് ഔട്ട്പുട്ട് സ്ട്രീം എഴുതുന്നതിന് കാരണമാകുന്നു; സ്ഥിരസ്ഥിതിയായി, ഔട്ട്പുട്ട് ആണ്
എഴുതിയത് stdout.

-f പ്രൊഫൈൽ
ഇൻപുട്ടിൽ എക്സിക്യൂട്ട് ചെയ്യുന്നതിനായി നിർദ്ദിഷ്ട ഫയലിലെ ഉള്ളടക്കങ്ങൾ പ്രോഗ്രാമായി ഉപയോഗിക്കുക. എങ്കിൽ
പ്രൊഫൈൽ ഒരു സ്ലാഷ് പ്രതീകം അടങ്ങിയിരിക്കുന്നു, പേര് ഫയലിന്റെ പാത്ത് നെയിം ആയി എടുക്കുന്നു.
അല്ലെങ്കിൽ, gvpr പരിസ്ഥിതി വേരിയബിളിൽ വ്യക്തമാക്കിയ ഡയറക്‌ടറികൾ ഉപയോഗിക്കും
GVPRPATH ഫയൽ തിരയാൻ. എങ്കിൽ -f നൽകിയിട്ടില്ല, gvpr ആദ്യത്തെ അല്ലാത്തത് ഉപയോഗിക്കും
പ്രോഗ്രാം ആയി ഓപ്ഷൻ ആർഗ്യുമെന്റ്.

-q മുന്നറിയിപ്പ് സന്ദേശങ്ങൾ ഓഫാക്കുന്നു.

-n ഗ്രാഫ് റീഡ്-അഹെഡ് ഓഫ് ചെയ്യുന്നു. സ്ഥിരസ്ഥിതിയായി, വേരിയബിൾ $NG അടുത്ത ഗ്രാഫിലേക്ക് സജ്ജീകരിച്ചിരിക്കുന്നു
പ്രോസസ്സ് ചെയ്യേണ്ടത്. ഇത് പ്രോസസ്സ് ചെയ്യുന്നതിന് മുമ്പ് അടുത്ത ഗ്രാഫ് വായിക്കേണ്ടതുണ്ട്
നിലവിലെ ഗ്രാഫ്, അടുത്ത ഗ്രാഫ് പ്രതികരണമായി മാത്രമേ ജനറേറ്റ് ചെയ്തിട്ടുള്ളൂവെങ്കിൽ അത് തടഞ്ഞേക്കാം
നിലവിലെ ഗ്രാഫിന്റെ പ്രോസസ്സിംഗുമായി ബന്ധപ്പെട്ട ചില പ്രവർത്തനങ്ങൾ.

-V പതിപ്പ് വിവരങ്ങൾ അച്ചടിച്ച് പുറത്തുകടക്കാൻ പ്രോഗ്രാമിന് കാരണമാകുന്നു.

-? ഉപയോഗ വിവരങ്ങൾ അച്ചടിച്ച് പുറത്തുകടക്കാൻ പ്രോഗ്രാമിന് കാരണമാകുന്നു.

പ്രവർത്തനങ്ങൾ

ഇനിപ്പറയുന്ന ഓപ്പറാൻറ് പിന്തുണയ്ക്കുന്നു:

ഫയലുകൾ ഡോട്ട് ഭാഷയിൽ ഒന്നോ അതിലധികമോ ഗ്രാഫുകൾ അടങ്ങിയ ഫയലുകളുടെ പേരുകൾ. അല്ലെങ്കിൽ -f ഓപ്ഷൻ
നൽകിയിരിക്കുന്നു, ആദ്യ പേര് പട്ടികയിൽ നിന്ന് നീക്കം ചെയ്യുകയും ഇൻപുട്ട് പ്രോഗ്രാമായി ഉപയോഗിക്കുകയും ചെയ്യുന്നു.
ഫയലുകളുടെ ലിസ്റ്റ് ശൂന്യമാണെങ്കിൽ, stdin ഉപയോഗിക്കും.

പ്രോഗ്രാമുകൾ

A gvpr പ്രോഗ്രാമിൽ ഒരു ഫോമുകളുള്ള പ്രവചന-ആക്ഷൻ ക്ലോസുകളുടെ ഒരു ലിസ്റ്റ് അടങ്ങിയിരിക്കുന്നു:

ആരംഭിക്കുന്നു { നടപടി }

BEG_G { നടപടി }

N [ പ്രവചിക്കുക ] { നടപടി }

E [ പ്രവചിക്കുക ] { നടപടി }

END_G { നടപടി }

അവസാനിക്കുന്നു { നടപടി }

ഒരു പ്രോഗ്രാമിൽ പരമാവധി ഓരോന്നിലും അടങ്ങിയിരിക്കാം ആരംഭിക്കുന്നു, END_G ഒപ്പം അവസാനിക്കുന്നു ഉപവാക്യങ്ങൾ. അവിടെ കഴിയും
ഏത് സംഖ്യയായാലും BEG_G, N ഒപ്പം E പ്രസ്താവനകൾ, ആദ്യത്തേത് ഗ്രാഫുകളിൽ പ്രയോഗിക്കുന്നു, രണ്ടാമത്തേത്
നോഡുകൾ, മൂന്നാമത്തേത് മുതൽ അരികുകൾ വരെ. ഇവയെ ബ്ലോക്കുകളായി വേർതിരിക്കുന്നു, ഒരു അടങ്ങുന്ന ഒരു ബ്ലോക്ക്
ഓപ്ഷണൽ BEG_G പ്രസ്താവനയും എല്ലാം N ഒപ്പം E അടുത്തത് വരെയുള്ള പ്രസ്താവനകൾ BEG_G പ്രസ്താവന, എങ്കിൽ
ഏതെങ്കിലും. a യുടെ ഉയർന്ന തലത്തിലുള്ള സെമാന്റിക്സ് gvpr പ്രോഗ്രാം ഇവയാണ്:

വിലയിരുത്തുക ആരംഭിക്കുന്നു എന്തെങ്കിലും ഉണ്ടെങ്കിൽ ക്ലോസ്.
ഓരോ ഇൻപുട്ട് ഗ്രാഫിനും G {
ഓരോ ബ്ലോക്കിനും {
ഗണം G നിലവിലെ ഗ്രാഫും നിലവിലെ വസ്തുവും ആയി.
വിലയിരുത്തുക BEG_G എന്തെങ്കിലും ഉണ്ടെങ്കിൽ ക്ലോസ്.
ഓരോ നോഡിനും എഡ്ജിനും G {
നിലവിലെ ഒബ്‌ജക്‌റ്റായി നോഡോ എഡ്ജോ സജ്ജമാക്കുക.
വിലയിരുത്തുക N or E വ്യവസ്ഥകൾ, ഉചിതമായത്.
}
}
ഗണം G നിലവിലെ വസ്തുവായി.
വിലയിരുത്തുക END_G എന്തെങ്കിലും ഉണ്ടെങ്കിൽ ക്ലോസ്.
}
വിലയിരുത്തുക അവസാനിക്കുന്നു എന്തെങ്കിലും ഉണ്ടെങ്കിൽ ക്ലോസ്.

യുടെ പ്രവർത്തനങ്ങൾ ആരംഭിക്കുന്നു, BEG_G, END_G ഒപ്പം അവസാനിക്കുന്നു ക്ലോസുകൾ ആയിരിക്കുമ്പോൾ ക്ലോസുകൾ നടപ്പിലാക്കുന്നു
വിലയിരുത്തി. വേണ്ടി N or E ഉപവാക്യങ്ങൾ, പ്രവചനമോ പ്രവൃത്തിയോ ഒഴിവാക്കാം. ഉണ്ടെങ്കിൽ
ഒരു പ്രവർത്തനത്തിന്റെ പ്രവചനമല്ല, ഓരോ നോഡിലും അല്ലെങ്കിൽ അരികിലും പ്രവർത്തനം നടത്തുന്നു
ഉചിതമായ. ഒരു പ്രവർത്തനവും ഇല്ലെങ്കിൽ, പ്രവചനം ശരിയാണെന്ന് വിലയിരുത്തുന്നുവെങ്കിൽ, ബന്ധപ്പെട്ടത്
ടാർഗെറ്റ് ഗ്രാഫിലേക്ക് നോഡോ എഡ്ജോ ചേർത്തിരിക്കുന്നു.

ബ്ലോക്കുകൾ അവ സംഭവിക്കുന്ന ക്രമത്തിൽ വിലയിരുത്തപ്പെടുന്നു. ഒരു ബ്ലോക്കിനുള്ളിൽ, ദി N ാ ം
(E വ്യവസ്ഥകൾ, യഥാക്രമം) സംഭവിക്കുന്ന ക്രമത്തിൽ വിലയിരുത്തപ്പെടുന്നു. എങ്കിലും ശ്രദ്ധിക്കുക
അത് ഒരു ബ്ലോക്കിനുള്ളിൽ, N or E യാത്രാ ക്രമത്തെ ആശ്രയിച്ച് ഉപവാക്യങ്ങൾ പരസ്പരം ബന്ധിപ്പിച്ചേക്കാം.

പ്രവചനങ്ങളും പ്രവർത്തനങ്ങളും പിന്തുണയ്ക്കുന്ന സി ഭാഷയിലുള്ള പ്രസ്താവനകളുടെ ക്രമങ്ങളാണ്
exr(3) ലൈബ്രറി. പ്രവചനങ്ങളും പ്രവർത്തനങ്ങളും തമ്മിലുള്ള വ്യത്യാസം ആദ്യത്തേത് മാത്രമാണ്
ശരിയോ തെറ്റോ എന്ന് വ്യാഖ്യാനിക്കാവുന്ന ഒരു തരം ഉണ്ടായിരിക്കണം. ഇവിടെ സാധാരണ സി
കൺവെൻഷൻ പിന്തുടരുന്നു, അതിൽ പൂജ്യമല്ലാത്ത മൂല്യം ശരിയാണെന്ന് കണക്കാക്കുന്നു. ഇതിൽ ഉൾപ്പെടും
നോഡുകൾ, അരികുകൾ മുതലായവയെ കുറിച്ചുള്ള ശൂന്യമല്ലാത്ത സ്ട്രിംഗുകളും ശൂന്യമല്ലാത്ത റഫറൻസുകളും. എന്നിരുന്നാലും, ഒരു സ്ട്രിംഗിന് കഴിയുമെങ്കിൽ
ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുക, ഈ മൂല്യം ഉപയോഗിക്കുന്നു.

സാധാരണ സി അടിസ്ഥാന തരങ്ങൾക്ക് പുറമേ (ശൂന്യം, int, പ്രതീകം, ഫ്ലോട്ട്, നീളമുള്ള, ഒപ്പിടാത്തത് ഒപ്പം ഇരട്ട),
gvpr നൽകുന്നു സ്ട്രിംഗ് എന്നതിന്റെ പര്യായമായി ചാര്*, ഗ്രാഫ് അധിഷ്ഠിത തരങ്ങൾ നോഡ്_ടി, എഡ്ജ്_ടി,
ഗ്രാഫ്_ടി ഒപ്പം obj_t. ദി obj_t തരത്തെ മറ്റ് 3 കോൺക്രീറ്റുകളുടെ സൂപ്പർ ടൈപ്പായി കാണാൻ കഴിയും
തരങ്ങൾ; ശരിയായ അടിസ്ഥാന തരം ചലനാത്മകമായി പരിപാലിക്കപ്പെടുന്നു. ഈ അടിസ്ഥാന തരങ്ങൾ കൂടാതെ, ദി
പിന്തുണയ്‌ക്കുന്ന മറ്റ് തരത്തിലുള്ള എക്‌സ്‌പ്രെഷനുകൾ മാത്രമാണ് (അസോസിയേറ്റീവ്) അറേകൾ.

സ്ഥിരാങ്കങ്ങൾ C വാക്യഘടനയെ പിന്തുടരുന്നു, എന്നാൽ സ്ട്രിംഗുകൾ ഒന്നിൽ കൂടി ഉദ്ധരിക്കാം "..." or '...'. gvpr
C++ അഭിപ്രായങ്ങളും cpp-തരം അഭിപ്രായങ്ങളും സ്വീകരിക്കുന്നു. രണ്ടാമത്തേതിന്, ഒരു വരി ആരംഭിക്കുകയാണെങ്കിൽ
ഒരു '#' പ്രതീകം, വരിയുടെ ബാക്കി ഭാഗം അവഗണിക്കപ്പെട്ടു.

ഒരു പ്രസ്‌താവന എന്നത് ഒരു ഫംഗ്‌ഷന്റെയോ വേരിയബിളിന്റെയോ ഒരു അറേയുടെയോ അല്ലെങ്കിൽ എക്‌സിക്യൂട്ടബിളിന്റെയോ പ്രഖ്യാപനം ആകാം.
പ്രസ്താവന. പ്രഖ്യാപനങ്ങൾക്ക്, ഒരൊറ്റ പരിധിയുണ്ട്. അറേ പ്രഖ്യാപനങ്ങൾക്ക് ഫോം ഉണ്ട്:

ടൈപ്പ് ചെയ്യുക ശ്രേണി [ type0 ]

എവിടെ type0 ഓപ്ഷണൽ ആണ്. ഇത് വിതരണം ചെയ്താൽ, എല്ലാ അറേയും പാർസർ നടപ്പിലാക്കും
സബ്സ്ക്രിപ്റ്റുകൾക്ക് നിർദ്ദിഷ്ട തരം ഉണ്ട്. അത് വിതരണം ചെയ്തില്ലെങ്കിൽ, എല്ലാ തരത്തിലുമുള്ള വസ്തുക്കൾ ആകാം
സബ്സ്ക്രിപ്റ്റുകളായി ഉപയോഗിക്കുന്നു. സിയിലേതുപോലെ, വേരിയബിളുകളും അറേകളും പ്രഖ്യാപിക്കണം. പ്രത്യേകിച്ച്, ഒരു
പ്രഖ്യാപിക്കാത്ത വേരിയബിളിനെ ഒരു നോഡിന്റെ, എഡ്ജിന്റെ അല്ലെങ്കിൽ ആട്രിബ്യൂട്ടിന്റെ പേരായി വ്യാഖ്യാനിക്കും
ഗ്രാഫ്, സന്ദർഭം അനുസരിച്ച്.

എക്സിക്യൂട്ടബിൾ സ്റ്റേറ്റ്‌മെന്റുകൾ ഇനിപ്പറയുന്നവയിൽ ഒന്നായിരിക്കാം:

{ [ പ്രസ്താവന ... ] }
പദപ്രയോഗം // സാധാരണയായി വേരിയബിൾ = പദപ്രയോഗം
എങ്കിൽ ( പദപ്രയോഗം ) പ്രസ്താവന [ മറ്റാരെങ്കിലും പ്രസ്താവന ]
വേണ്ടി( പദപ്രയോഗം ; പദപ്രയോഗം ; പദപ്രയോഗം ) പ്രസ്താവന
വേണ്ടി( ശ്രേണി [ വേരിയബിൾ ]) പ്രസ്താവന
ഫോർ( ശ്രേണി [ വേരിയബിൾ ]) പ്രസ്താവന
അതേസമയം ( പദപ്രയോഗം ) പ്രസ്താവന
സ്വിച്ചുചെയ്യുക ( പദപ്രയോഗം ) കേസ് പ്രസ്താവനകൾ
ഇടവേള [ പദപ്രയോഗം ]
തുടരുക [ പദപ്രയോഗം ]
മടക്കം [ പദപ്രയോഗം ]
ബ്രാക്കറ്റിലുള്ള ഇനങ്ങൾ ഓപ്ഷണൽ ആണ്.

രണ്ടാമത്തെ രൂപത്തിൽ വേണ്ടി പ്രസ്താവനയും forr പ്രസ്താവന, വേരിയബിൾ വേരിയബിൾ എന്നതിലേക്ക് സജ്ജമാക്കി
ഓരോ മൂല്യവും നിർദ്ദിഷ്ട ശ്രേണിയിലെ ഒരു സൂചികയായും തുടർന്ന് അനുബന്ധമായും ഉപയോഗിക്കുന്നു പ്രസ്താവന is
വിലയിരുത്തി. സംഖ്യാ സൂചികകൾക്കും സ്ട്രിംഗ് സൂചികകൾക്കും, സൂചികകൾ വർദ്ധിക്കുന്നതിലാണ് മടങ്ങുന്നത്
(കുറയുന്നു) എന്നതിനായുള്ള സംഖ്യാ അല്ലെങ്കിൽ നിഘണ്ടു ക്രമം വേണ്ടി (forr, യഥാക്രമം). ഇത് ഉപയോഗിക്കാം
അടുക്കുന്നതിന്.

ഫംഗ്‌ഷൻ നിർവചനങ്ങൾ എന്നതിൽ മാത്രമേ ദൃശ്യമാകൂ ആരംഭിക്കുന്നു ഉപവാക്യം.

എക്സ്പ്രഷനുകളിൽ സാധാരണ സി എക്സ്പ്രഷനുകൾ ഉൾപ്പെടുന്നു. ഉപയോഗിച്ച് സ്ട്രിംഗ് താരതമ്യങ്ങൾ == ഒപ്പം != ചികിത്സിക്കുക
വലത് കൈ ഓപ്പറാൻറ് പതിവ് എക്സ്പ്രഷൻ പൊരുത്തത്തിന്റെ ഉദ്ദേശ്യത്തിനായി ഒരു പാറ്റേണായി. പാറ്റേണുകൾ
ഉപയോഗം ksh(1) ഫയൽ മാച്ച് പാറ്റേൺ വാക്യഘടന. (ലളിതമായ സ്ട്രിംഗ് സമത്വത്തിന്, ഉപയോഗിക്കുക strcmp
പ്രവർത്തനം.

gvpr ഒരു പദപ്രയോഗം ഒരു സ്ട്രിംഗ് അല്ലെങ്കിൽ സംഖ്യാ മൂല്യം ആയി ഉപയോഗിക്കാൻ ശ്രമിക്കും. രണ്ടും
സാധ്യമെങ്കിൽ, C-പോലുള്ള കാസ്റ്റുകളും ഫംഗ്‌ഷൻ ടെംപ്ലേറ്റുകളും പരിവർത്തനങ്ങൾ നടത്താൻ ഇടയാക്കും.

ഗ്രാഫിക്കൽ തരത്തിലുള്ള എക്സ്പ്രഷനുകൾ (അതായത്, graph_t, നോഡ്_ടി, എഡ്ജ്_ടി, obj_t) പിന്തുടരാം a
രൂപത്തിൽ ഫീൽഡ് റഫറൻസ് .പേര്. തത്ഫലമായുണ്ടാകുന്ന മൂല്യം ആട്രിബ്യൂട്ടിന്റെ മൂല്യമാണ്
പേരുനൽകിയത് പേര് തന്നിരിക്കുന്ന വസ്തുവിന്റെ. കൂടാതെ, ചില സന്ദർഭങ്ങളിൽ ഒരു അപ്രഖ്യാപിത,
മാറ്റാത്ത ഐഡന്റിഫയർ ഒരു ആട്രിബ്യൂട്ട് നാമമായി കണക്കാക്കുന്നു. പ്രത്യേകിച്ചും, അത്തരം ഐഡന്റിഫയറുകൾ
യഥാക്രമം നിലവിലെ നോഡിന്റെയോ എഡ്ജിന്റെയോ ആട്രിബ്യൂട്ടുകളെ സൂചിപ്പിക്കുക N ഒപ്പം E ഉപവാക്യങ്ങൾ, കൂടാതെ
നിലവിലെ ഗ്രാഫ് BEG_G ഒപ്പം END_G ഉപവാക്യങ്ങൾ.

സാധാരണ പോലെ ലിബ്സിഗ്രാഫ്(3) മോഡൽ, ആട്രിബ്യൂട്ടുകൾ സ്ട്രിംഗ് മൂല്യമുള്ളതാണ്. ഇതുകൂടാതെ, gvpr
ഗ്രാഫ് ഒബ്‌ജക്‌റ്റുകളുടെ ചില കപട-ആട്രിബ്യൂട്ടുകളെ പിന്തുണയ്‌ക്കുന്നു, സ്‌ട്രിംഗ്-മൂല്യം ആവശ്യമില്ല. ഇവ
ഗ്രാഫ് ഒബ്‌ജക്‌റ്റുകളുടെ അന്തർലീനമായ ഗുണങ്ങളെ പ്രതിഫലിപ്പിക്കുന്നു, ഉപയോക്താവിന് അത് സജ്ജമാക്കാൻ കഴിയില്ല.

തല : നോഡ്_ടി
ഒരു അരികിന്റെ തല.

വാൽ : നോഡ്_ടി
ഒരു അരികിന്റെ വാൽ.

പേര് : സ്ട്രിംഗ്
ഒരു എഡ്ജ്, നോഡ് അല്ലെങ്കിൽ ഗ്രാഫ് എന്നിവയുടെ പേര്. ഒരു അരികിന്റെ പേരിന് ഒരു രൂപമുണ്ട് "<വാൽ-
പേര്>[]", എവിടെ ആണ് "->" അഥവാ "--" ഇതിനെ ആശ്രയിച്ച്
ഗ്രാഫ് സംവിധാനം ചെയ്താലും ഇല്ലെങ്കിലും. ബ്രാക്കറ്റ് ഭാഗം [] എങ്കിൽ മാത്രമേ ദൃശ്യമാകൂ
എഡ്ജിന് നിസ്സാരമല്ലാത്ത ഒരു കീ ഉണ്ട്.

ബിരുദം : int
ഒരു നോഡിന്റെ അളവ്.

ബിരുദം : int
ഒരു നോഡിന്റെ ഔട്ട്ഡിഗ്രി.

ഡിഗ്രി : int
ഒരു നോഡിന്റെ അളവ്.

വേര് : ഗ്രാഫ്_ടി
ഒരു വസ്തുവിന്റെ റൂട്ട് ഗ്രാഫ്. ഒരു റൂട്ട് ഗ്രാഫിന്റെ റൂട്ട് തന്നെയാണ്.

പാരന്റ് : ഗ്രാഫ്_ടി
ഒരു ഉപഗ്രാഫിന്റെ പാരന്റ് ഗ്രാഫ്. ഒരു റൂട്ട് ഗ്രാഫിന്റെ പാരന്റ് ആണ് NULL

n_അറ്റങ്ങൾ : int
ഗ്രാഫിലെ അരികുകളുടെ എണ്ണം

n_നോഡുകൾ : int
ഗ്രാഫിലെ നോഡുകളുടെ എണ്ണം

സംവിധാനം : int
ഗ്രാഫ് ഡയറക്‌റ്റ് ചെയ്‌താൽ ശരി (പൂജ്യം അല്ലാത്തത്).

കണിശമായ : int
ഗ്രാഫ് കർശനമാണെങ്കിൽ ശരി (പൂജ്യം അല്ലാത്തത്).

ബിൽറ്റ്-ഇൻ പ്രവർത്തനങ്ങൾ

ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ അന്തർനിർമ്മിതമാണ് gvpr. ആ ഫംഗ്‌ഷനുകൾ ഗ്രാഫിലേക്ക് റഫറൻസുകൾ നൽകുന്നു
വസ്തുക്കൾ തിരികെ വരുന്നു NULL പരാജയപ്പെട്ടാൽ.

ഗ്രാഫുകൾ ഒപ്പം ഉപഗ്രാഫ്
ഗ്രാഫ്(s : സ്ട്രിംഗ്, t : സ്ട്രിംഗ്): ഗ്രാഫ്_ടി
പേരുള്ള ഒരു ഗ്രാഫ് സൃഷ്ടിക്കുന്നു s കൂടാതെ ആരുടെ തരം സ്ട്രിംഗിൽ വ്യക്തമാക്കിയിരിക്കുന്നു t.
കഥാപാത്രങ്ങളെ അവഗണിക്കുന്നു U, D, S, N വ്യാഖ്യാനം വഴിതിരിച്ചുവിടരുത്,
യഥാക്രമം നിർദ്ദേശിച്ചതും കർശനവും അല്ലാത്തതും. എങ്കിൽ t ശൂന്യമാണ്, നിർദ്ദേശിച്ചതും അല്ലാത്തതുമാണ്
കർശനമായ ഗ്രാഫ് സൃഷ്ടിക്കപ്പെടുന്നു.

സബ്ജി(g : ഗ്രാഫ്_ടി, s : സ്ട്രിംഗ്): ഗ്രാഫ്_ടി
ഗ്രാഫിൽ ഒരു സബ്ഗ്രാഫ് സൃഷ്ടിക്കുന്നു g പേരിനൊപ്പം s. സബ്ഗ്രാഫ് ഇതിനകം നിലവിലുണ്ടെങ്കിൽ, അത്
മടങ്ങി.

isSubg(g : ഗ്രാഫ്_ടി, s : സ്ട്രിംഗ്): ഗ്രാഫ്_ടി
ഗ്രാഫിലെ സബ്ഗ്രാഫ് നൽകുന്നു g പേരിനൊപ്പം s, അത് നിലവിലുണ്ടെങ്കിൽ, അല്ലെങ്കിൽ NULL അല്ലെങ്കിൽ.

fstsubg(g : ഗ്രാഫ്_ടി): ഗ്രാഫ്_ടി
ഗ്രാഫിലെ ആദ്യ ഉപഗ്രാഫ് നൽകുന്നു g, അഥവാ NULL ഒന്നുമില്ലെങ്കിൽ.

nxtsubg(sg : ഗ്രാഫ്_ടി): ഗ്രാഫ്_ടി
ശേഷം അടുത്ത സബ്ഗ്രാഫ് നൽകുന്നു sg, അഥവാ NULL.

നേരിട്ട് ആണ്(g : ഗ്രാഫ്_ടി): int
എങ്കിൽ മാത്രം ശരി എന്ന് നൽകുന്നു g സംവിധാനം.

കർശനമാണ്(g : ഗ്രാഫ്_ടി): int
എങ്കിൽ മാത്രം ശരി എന്ന് നൽകുന്നു g കർശനമാണ്.

നോഡുകൾ(g : ഗ്രാഫ്_ടി): int
നോഡുകളുടെ എണ്ണം നൽകുന്നു g.

nEdges(g : ഗ്രാഫ്_ടി): int
അരികുകളുടെ എണ്ണം നൽകുന്നു g.

നോഡുകൾ
നോഡ്(sg : ഗ്രാഫ്_ടി, s : സ്ട്രിംഗ്): നോഡ്_ടി
ഗ്രാഫിൽ ഒരു നോഡ് സൃഷ്ടിക്കുന്നു g പേരിന്റെ s. അത്തരമൊരു നോഡ് ഇതിനകം നിലവിലുണ്ടെങ്കിൽ, അത് തിരികെ നൽകും.

ഉപനോഡ്(sg : ഗ്രാഫ്_ടി, n : നോഡ്_ടി): നോഡ്_ടി
നോഡ് ചേർക്കുന്നു n ഉപഗ്രാഫിലേക്ക് g. നോഡ് തിരികെ നൽകുന്നു.

fstnode(g : ഗ്രാഫ്_ടി): നോഡ്_ടി
ഗ്രാഫിലെ ആദ്യ നോഡ് നൽകുന്നു g, അഥവാ NULL ഒന്നുമില്ലെങ്കിൽ.

nxtnode(n : നോഡ്_ടി): നോഡ്_ടി
ശേഷം അടുത്ത നോഡ് നൽകുന്നു n റൂട്ട് ഗ്രാഫിൽ, അല്ലെങ്കിൽ NULL.

nxtnode_sg(sg : ഗ്രാഫ്_ടി, n : നോഡ്_ടി): നോഡ്_ടി
ശേഷം അടുത്ത നോഡ് നൽകുന്നു n in sg, അഥവാ NULL.

നോഡ് ആണ്(sg : ഗ്രാഫ്_ടി, s : സ്ട്രിംഗ്): നോഡ്_ടി
(ഉപ)ഗ്രാഫിൽ ഒരു നോഡിനായി തിരയുന്നു sg പേരിന്റെ s. അത്തരമൊരു നോഡ് നിലവിലുണ്ടെങ്കിൽ, അത് തിരികെ നൽകും.
അല്ലെങ്കിൽ, NULL തിരികെ നൽകപ്പെടുന്നു.

ഉപനോഡ്(sg : ഗ്രാഫ്_ടി, n : നോഡ്_ടി): int
നോഡ് ആണെങ്കിൽ നോൺ-പൂജ്യം നൽകുന്നു n (ഉപ)ഗ്രാഫിലാണ് sg, അല്ലെങ്കിൽ പൂജ്യം അല്ലെങ്കിൽ.

indegreeOf(sg : ഗ്രാഫ്_ടി, n : നോഡ്_ടി): int
നോഡിന്റെ ഡിഗ്രി നൽകുന്നു n (ഉപ)ഗ്രാഫിൽ sg.

ഔട്ട്ഡിഗ്രിഓഫ്(sg : ഗ്രാഫ്_ടി, n : നോഡ്_ടി): int
നോഡിന്റെ ഔട്ട്ഡിഗ്രി നൽകുന്നു n (ഉപ)ഗ്രാഫിൽ sg.

ബിരുദം(sg : ഗ്രാഫ്_ടി, n : നോഡ്_ടി): int
നോഡിന്റെ ബിരുദം നൽകുന്നു n (ഉപ)ഗ്രാഫിൽ sg.

അരികുകൾ
അറ്റം(t : നോഡ്_ടി, h : നോഡ്_ടി, s : സ്ട്രിംഗ്): എഡ്ജ്_ടി
ടെയിൽ നോഡിനൊപ്പം ഒരു എഡ്ജ് സൃഷ്ടിക്കുന്നു t, തല നോഡ് h പേരും s റൂട്ട് ഗ്രാഫിൽ. എങ്കിൽ
ഗ്രാഫ് ദിശാബോധമില്ലാത്തതാണ്, തലയും വാൽ നോഡുകളും തമ്മിലുള്ള വ്യത്യാസം അപ്രധാനമാണ്.
അത്തരമൊരു എഡ്ജ് ഇതിനകം നിലവിലുണ്ടെങ്കിൽ, അത് തിരികെ നൽകും.

എഡ്ജ്_sg(sg : ഗ്രാഫ്_ടി, t : നോഡ്_ടി, h : നോഡ്_ടി, s : സ്ട്രിംഗ്): എഡ്ജ്_ടി
ടെയിൽ നോഡിനൊപ്പം ഒരു എഡ്ജ് സൃഷ്ടിക്കുന്നു t, തല നോഡ് h പേരും s (ഉപ)ഗ്രാഫിൽ sg (എല്ലാം
പാരന്റ് ഗ്രാഫുകൾ). ഗ്രാഫ് ദിശ തെറ്റിയില്ലെങ്കിൽ, തലയും വാലും തമ്മിലുള്ള വ്യത്യാസം
നോഡുകൾ അപ്രധാനമാണ്. അത്തരമൊരു എഡ്ജ് ഇതിനകം നിലവിലുണ്ടെങ്കിൽ, അത് തിരികെ നൽകും.

കീഴ്ഭാഗം(g : ഗ്രാഫ്_ടി, e : എഡ്ജ്_ടി): എഡ്ജ്_ടി
അറ്റം തിരുകുന്നു e ഉപഗ്രാഫിലേക്ക് g. എഡ്ജ് തിരികെ നൽകുന്നു.

isEdge(t : നോഡ്_ടി, h : നോഡ്_ടി, s : സ്ട്രിംഗ്): എഡ്ജ്_ടി
ടെയിൽ നോഡുള്ള ഒരു അരികിനായി നോക്കുന്നു t, തല നോഡ് h പേരും s. ഗ്രാഫ് ആണെങ്കിൽ
ദിശയില്ലാതെ, തലയുടെയും വാലിന്റെയും നോഡുകൾ തമ്മിലുള്ള വ്യത്യാസം അപ്രധാനമാണ്. അങ്ങനെയെങ്കിൽ
എഡ്ജ് നിലവിലുണ്ട്, അത് തിരികെ നൽകുന്നു. അല്ലെങ്കിൽ, NULL തിരികെ നൽകപ്പെടുന്നു.

isEdge_sg(sg : ഗ്രാഫ്_ടി, t : നോഡ്_ടി, h : നോഡ്_ടി, s : സ്ട്രിംഗ്): എഡ്ജ്_ടി
ടെയിൽ നോഡുള്ള ഒരു അരികിനായി നോക്കുന്നു t, തല നോഡ് h പേരും s (ഉപ)ഗ്രാഫിൽ sg. ആണെങ്കിൽ
ഗ്രാഫ് ദിശാബോധമില്ലാത്തതാണ്, തലയും വാൽ നോഡുകളും തമ്മിലുള്ള വ്യത്യാസം അപ്രധാനമാണ്.
അത്തരമൊരു എഡ്ജ് നിലവിലുണ്ടെങ്കിൽ, അത് തിരികെ നൽകും. അല്ലെങ്കിൽ, NULL തിരികെ നൽകപ്പെടുന്നു.

സബ്ബെഡ്ജ്(g : ഗ്രാഫ്_ടി, e : എഡ്ജ്_ടി): int
എഡ്ജ് ആണെങ്കിൽ നോൺ-പൂജ്യം നൽകുന്നു e (ഉപ)ഗ്രാഫിലാണ് sg, അല്ലെങ്കിൽ പൂജ്യം അല്ലെങ്കിൽ.

fstout(n : നോഡ്_ടി): എഡ്ജ്_ടി
നോഡിന്റെ ആദ്യ ഔട്ട്ഡേജ് നൽകുന്നു n റൂട്ട് ഗ്രാഫിൽ.

fstout_sg(sg : ഗ്രാഫ്_ടി, n : നോഡ്_ടി): എഡ്ജ്_ടി
നോഡിന്റെ ആദ്യ ഔട്ട്ഡേജ് നൽകുന്നു n (ഉപ)ഗ്രാഫിൽ sg.

nxtout(e : എഡ്ജ്_ടി): എഡ്ജ്_ടി
ശേഷം അടുത്ത ഔട്ട് എഡ്ജ് തിരികെ നൽകുന്നു e റൂട്ട് ഗ്രാഫിൽ.

nxtout_sg(sg : ഗ്രാഫ്_ടി, e : എഡ്ജ്_ടി): എഡ്ജ്_ടി
ശേഷം അടുത്ത ഔട്ട് എഡ്ജ് തിരികെ നൽകുന്നു e ഗ്രാഫിൽ sg.

fstin(n : നോഡ്_ടി): എഡ്ജ്_ടി
നോഡിന്റെ ആദ്യ ഇഞ്ച് നൽകുന്നു n റൂട്ട് ഗ്രാഫിൽ.

fstin_sg(sg : ഗ്രാഫ്_ടി, n : നോഡ്_ടി): എഡ്ജ്_ടി
നോഡിന്റെ ആദ്യ ഇഞ്ച് നൽകുന്നു n ഗ്രാഫിൽ sg.

nxtin(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.

opp(e : എഡ്ജ്_ടി, നോഡ്_ടി): നോഡ്_ടി
അരികിലുള്ള നോഡ് തിരികെ നൽകുന്നു e തുല്യമല്ല n. എങ്കിൽ NULL നൽകുന്നു n എന്ന നോഡ് അല്ല
e. ഉപയോഗിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാകും fstedge ഒപ്പം nxtedge അയൽക്കാരെ എണ്ണാൻ
n.

ഗ്രാഫ് ഐ / ഒ
എഴുതുക(g : ഗ്രാഫ്_ടി): ശൂന്യം
പ്രിന്റുകൾ g ഔട്ട്പുട്ട് സ്ട്രീമിലേക്ക് ഡോട്ട് ഫോർമാറ്റിൽ.

എഴുതുക ജി(g : ഗ്രാഫ്_ടി, പേര് : സ്ട്രിംഗ്): ശൂന്യം
പ്രിന്റുകൾ g ഫയലിലേക്ക് ഡോട്ട് ഫോർമാറ്റിൽ പേര്.

fwriteG(g : ഗ്രാഫ്_ടി, fd : int): ശൂന്യം
പ്രിന്റുകൾ g പൂർണ്ണസംഖ്യ കൊണ്ട് സൂചിപ്പിച്ച ഓപ്പൺ സ്ട്രീമിലേക്ക് ഡോട്ട് ഫോർമാറ്റിൽ fd.

വായിക്കുക ജി(പേര് : സ്ട്രിംഗ്): ഗ്രാഫ്_ടി
ഫയലിൽ നിന്ന് വായിച്ച ഒരു ഗ്രാഫ് നൽകുന്നു പേര്. ഗ്രാഫ് ഡോട്ട് ഫോർമാറ്റിൽ ആയിരിക്കണം. അല്ലെങ്കിൽ
ഗ്രാഫ് വായിക്കാം, NULL തിരികെ നൽകപ്പെടുന്നു.

freadG(fd : int): ഗ്രാഫ്_ടി
ഓപ്പൺ സ്ട്രീമിൽ നിന്ന് വായിച്ച അടുത്ത ഗ്രാഫ് നൽകുന്നു fd. മടങ്ങുന്നു NULL ഫയലിന്റെ അവസാനം.

ഗ്രാഫ് പലതരം
ഇല്ലാതാക്കുക(g : ഗ്രാഫ്_ടി, x : obj_t): ശൂന്യം
ഒബ്ജക്റ്റ് ഇല്ലാതാക്കുന്നു x ഗ്രാഫിൽ നിന്ന് g. എങ്കിൽ g is NULL, ഫംഗ്ഷൻ റൂട്ട് ഗ്രാഫ് ഉപയോഗിക്കുന്നു
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 ഒരുപക്ഷേ NULL, ഈ സാഹചര്യത്തിൽ ക്ലോൺ ചെയ്ത വസ്തു ഒരു പുതിയ റൂട്ട് ആയിരിക്കും
ഗ്രാഫ്. ഈ സാഹചര്യത്തിൽ, കോൾ തുല്യമാണ് ക്ലോൺജി(x,"").

പകർത്തുക(g : ഗ്രാഫ്_ടി, x : obj_t): obj_t
വസ്തുവിന്റെ ഒരു പകർപ്പ് സൃഷ്ടിക്കുന്നു x ഗ്രാഫിൽ g, പുതിയ ഒബ്‌ജക്റ്റിന് ഒരേ പേര്/മൂല്യം ഉള്ളിടത്ത്
യഥാർത്ഥ വസ്തുവായി ആട്രിബ്യൂട്ടുകൾ. ഒരേ കീ ഉള്ള ഒരു വസ്തുവാണെങ്കിൽ x ഇതിനകം
നിലവിലുണ്ട്, അതിന്റെ ആട്രിബ്യൂട്ടുകൾ ഇവയുടെ ആട്രിബ്യൂട്ടുകളാൽ പൊതിഞ്ഞതാണ് x വസ്തു തിരികെ കിട്ടുകയും ചെയ്യുന്നു. കുറിപ്പ്
ഇതൊരു ആഴം കുറഞ്ഞ പകർപ്പാണെന്ന്. എങ്കിൽ x ഒരു ഗ്രാഫ് ആണ്, അതിന്റെ നോഡുകളോ അരികുകളോ ഉപഗ്രാഫുകളോ ഒന്നുമില്ല
പുതിയ ഗ്രാഫിലേക്ക് പകർത്തുന്നു. എങ്കിൽ x ഒരു എഡ്ജ് ആണ്, എങ്കിൽ അവസാന പോയിന്റുകൾ സൃഷ്ടിക്കപ്പെടുന്നു
ആവശ്യമാണ്, പക്ഷേ അവ ക്ലോൺ ചെയ്തിട്ടില്ല. എങ്കിൽ x ഒരു ഗ്രാഫ് ആണ്, g ഒരുപക്ഷേ NULL, ഏത് സാഹചര്യത്തിൽ
ക്ലോൺ ചെയ്ത വസ്തു ഒരു പുതിയ റൂട്ട് ഗ്രാഫ് ആയിരിക്കും.

കോപ്പിഎ(ഉറവിട : obj_t, tgt : obj_t): int
വസ്തുവിന്റെ ആട്രിബ്യൂട്ടുകൾ പകർത്തുന്നു ഉറവിട എതിർക്കാൻ tgt, ഏതെങ്കിലും ആട്രിബ്യൂട്ട് മൂല്യങ്ങൾ തിരുത്തിയെഴുതുന്നു
tgt തുടക്കത്തിൽ ഉണ്ടായേക്കാം.

പ്രേരിപ്പിക്കുക(g : ഗ്രാഫ്_ടി): ശൂന്യം
വിപുലീകരിക്കുന്നു g അതിന്റെ റൂട്ട് ഗ്രാഫിലെ നോഡ്-ഇൻഡ്യൂസ്ഡ് സബ്ഗ്രാഫ് എക്സ്റ്റൻഷനിലേക്ക്.

ഉണ്ട്Attr(ഉറവിട : obj_t, പേര് : സ്ട്രിംഗ്): int
ഒബ്‌ജക്റ്റ് ആണെങ്കിൽ പൂജ്യമല്ല എന്ന് നൽകുന്നു ഉറവിട പേരുള്ള ഒരു ആട്രിബ്യൂട്ട് ഉണ്ട് പേര്. ഇത് 0 നൽകുന്നു
അല്ലെങ്കിൽ.

ആണ്Attr(g : ഗ്രാഫ്_ടി, ദയയോടെ : സ്ട്രിംഗ്, പേര് : സ്ട്രിംഗ്): int
ഒരു ആട്രിബ്യൂട്ട് ആണെങ്കിൽ പൂജ്യമല്ലാത്തത് നൽകുന്നു പേര് ൽ നിർവചിച്ചിരിക്കുന്നു g യുടെ വസ്തുക്കൾക്ക്
നൽകപ്പെട്ട ദയയോടെ. നോഡുകൾ, അരികുകൾ, ഗ്രാഫുകൾ എന്നിവയ്ക്കായി, ദയയോടെ "N", "E", "G" എന്നിവ ആയിരിക്കണം,
യഥാക്രമം. ഇത് 0 തിരികെ നൽകുന്നു.

നേടുക(ഉറവിട : obj_t, പേര് : സ്ട്രിംഗ്): സ്ട്രിംഗ്
ആട്രിബ്യൂട്ടിന്റെ മൂല്യം നൽകുന്നു പേര് വസ്തുവിൽ ഉറവിട. അത്തരം സന്ദർഭങ്ങളിൽ ഇത് ഉപയോഗപ്രദമാണ്
എപ്പോൾ പേര് "ഹെഡ്" അല്ലെങ്കിൽ "റൂട്ട്" പോലുള്ള കീവേഡുകളിലൊന്നുമായി വൈരുദ്ധ്യം. എങ്കിൽ
ഗ്രാഫിൽ ആട്രിബ്യൂട്ട് പ്രഖ്യാപിച്ചിട്ടില്ല, ഫംഗ്ഷൻ ഇത് ഉപയോഗിച്ച് ആരംഭിക്കും
"" ന്റെ സ്ഥിര മൂല്യം. ഇത് ഒഴിവാക്കാൻ, ഒരാൾ ഉപയോഗിക്കണം ഉണ്ട്Attr or ആണ്Attr ഫംഗ്ഷൻ
ആട്രിബ്യൂട്ട് നിലവിലുണ്ടോ എന്ന് പരിശോധിക്കാൻ.

ഒരു സെറ്റ്(ഉറവിട : obj_t, പേര് : സ്ട്രിംഗ്, മൂല്യം : സ്ട്രിംഗ്): int
ആട്രിബ്യൂട്ടിന്റെ മൂല്യം സജ്ജമാക്കുന്നു പേര് വസ്തുവിൽ ഉറവിട ലേക്ക് മൂല്യം. വിജയത്തിൽ 0 മടങ്ങുന്നു,
പരാജയത്തിൽ പൂജ്യമല്ലാത്തത്. കാണുക നേടുക മുകളിൽ.

getDflt(g : ഗ്രാഫ്_ടി, ദയയോടെ : സ്ട്രിംഗ്, പേര് : സ്ട്രിംഗ്): സ്ട്രിംഗ്
ആട്രിബ്യൂട്ടിന്റെ ഡിഫോൾട്ട് മൂല്യം നൽകുന്നു പേര് ഉള്ള വസ്തുക്കളിൽ g നൽകിയതിന്റെ ദയയോടെ. വേണ്ടി
നോഡുകൾ, അരികുകൾ, ഗ്രാഫുകൾ, ദയയോടെ യഥാക്രമം "N", "E", "G" എന്നിവ ആയിരിക്കണം. എങ്കിൽ
ഗ്രാഫിൽ ആട്രിബ്യൂട്ട് പ്രഖ്യാപിച്ചിട്ടില്ല, ഫംഗ്ഷൻ ഇത് ഉപയോഗിച്ച് ആരംഭിക്കും
"" ന്റെ സ്ഥിര മൂല്യം. ഇത് ഒഴിവാക്കാൻ, ഒരാൾ ഉപയോഗിക്കണം ആണ്Attr പരിശോധിക്കുന്നതിനുള്ള പ്രവർത്തനം
ആട്രിബ്യൂട്ട് നിലവിലുണ്ടെന്ന്.

setDflt(g : ഗ്രാഫ്_ടി, ദയയോടെ : സ്ട്രിംഗ്, പേര് : സ്ട്രിംഗ്, മൂല്യം : സ്ട്രിംഗ്): int
ആട്രിബ്യൂട്ടിന്റെ ഡിഫോൾട്ട് മൂല്യം സജ്ജമാക്കുന്നു പേര് ലേക്ക് മൂല്യം ഉള്ള വസ്തുക്കളിൽ g നൽകിയതിന്റെ
ദയയോടെ. നോഡുകൾ, അരികുകൾ, ഗ്രാഫുകൾ എന്നിവയ്ക്കായി, ദയയോടെ യഥാക്രമം "N", "E", "G" എന്നിവ ആയിരിക്കണം.
വിജയത്തിൽ 0 നൽകുന്നു, പരാജയത്തിൽ പൂജ്യമല്ല. കാണുക getDflt മുകളിൽ.

fstAttr(g : ഗ്രാഫ്_ടി, ദയയോടെ : സ്ട്രിംഗ്): സ്ട്രിംഗ്
ഒബ്‌ജക്‌റ്റുകളുടെ ആദ്യ ആട്രിബ്യൂട്ടിന്റെ പേര് നൽകുന്നു g നൽകിയതിന്റെ ദയയോടെ. വേണ്ടി
നോഡുകൾ, അരികുകൾ, ഗ്രാഫുകൾ, ദയയോടെ യഥാക്രമം "N", "E", "G" എന്നിവ ആയിരിക്കണം. ഉണ്ടെങ്കിൽ
ആട്രിബ്യൂട്ടുകളൊന്നുമില്ല, "" എന്ന സ്ട്രിംഗ് തിരികെ നൽകി.

nxtAttr(g : ഗ്രാഫ്_ടി, ദയയോടെ : സ്ട്രിംഗ്, പേര് : സ്ട്രിംഗ്): സ്ട്രിംഗ്
ഒബ്‌ജക്‌റ്റുകളുടെ അടുത്ത ആട്രിബ്യൂട്ടിന്റെ പേര് നൽകുന്നു g നൽകിയതിന്റെ ദയയോടെ ശേഷം
ആട്രിബ്യൂട്ട് പേര്. വാദം പേര് നിലവിലുള്ള ഒരു ആട്രിബ്യൂട്ടിന്റെ പേരായിരിക്കണം; അത്
സാധാരണ ഒരു മുൻ കോളിന്റെ റിട്ടേൺ മൂല്യമായിരിക്കും fstAttr or nxtAttr. വേണ്ടി
നോഡുകൾ, അരികുകൾ, ഗ്രാഫുകൾ, ദയയോടെ യഥാക്രമം "N", "E", "G" എന്നിവ ആയിരിക്കണം. ഉണ്ടെങ്കിൽ
ആട്രിബ്യൂട്ടുകളൊന്നും അവശേഷിക്കുന്നില്ല, "" എന്ന സ്ട്രിംഗ് തിരികെ നൽകി.

compOf(g : ഗ്രാഫ്_ടി, n : നോഡ്_ടി): ഗ്രാഫ്_ടി
ഗ്രാഫിന്റെ ബന്ധിപ്പിച്ച ഘടകം തിരികെ നൽകുന്നു g നോഡ് അടങ്ങിയിരിക്കുന്നു n, ഒരു ഉപഗ്രാഫ് ആയി
g. ഉപഗ്രാഫിൽ നോഡുകൾ മാത്രമേ അടങ്ങിയിട്ടുള്ളൂ. ഒരാൾക്ക് ഉപയോഗിക്കാം പ്രേരിപ്പിക്കുക അറ്റങ്ങൾ ചേർക്കാൻ. ദി
ഫംഗ്‌ഷൻ പരാജയപ്പെടുകയും മടങ്ങുകയും ചെയ്യുന്നു NULL if n ഉള്ളിലല്ല g. കണക്റ്റിവിറ്റി അടിസ്ഥാനമാക്കിയുള്ളതാണ്
ന്റെ അണ്ടർ ഡയറക്‌ട് ചെയ്യാത്ത ഗ്രാഫ് g.

ഇത്തരം(ഒബ്ജക്റ്റ് : obj_t): സ്ട്രിംഗ്
തരത്തിന്റെ ഒരു സൂചന നൽകുന്നു ഒബ്ജക്റ്റ്. നോഡുകൾ, അരികുകൾ, ഗ്രാഫുകൾ എന്നിവയ്ക്കായി, അത് തിരികെ നൽകുന്നു
യഥാക്രമം "N", "E", "G".

ലോക്ക്(g : ഗ്രാഫ്_ടി, v : int): int
റൂട്ട് ഗ്രാഫുകളിൽ ഗ്രാഫ് ലോക്കിംഗ് നടപ്പിലാക്കുന്നു. പൂർണ്ണസംഖ്യയാണെങ്കിൽ v പോസിറ്റീവ് ആണ്, ഗ്രാഫ് ആണ്
ഭാവിയിൽ വിളിക്കുന്ന തരത്തിൽ സജ്ജമാക്കുക ഇല്ലാതാക്കുക പെട്ടെന്നുള്ള ഫലമില്ല. എങ്കിൽ v പൂജ്യമാണ്, the
ഗ്രാഫ് അൺലോക്ക് ചെയ്തു. ഗ്രാഫ് ആയിരിക്കുമ്പോൾ അത് ഇല്ലാതാക്കാൻ ഒരു കോൾ ഉണ്ടായിട്ടുണ്ടെങ്കിൽ
ലോക്ക് ചെയ്തു, ഗ്രാഫ് അടച്ചിരിക്കുന്നു. എങ്കിൽ v നെഗറ്റീവ് ആണ്, ഒന്നും ചെയ്തിട്ടില്ല. എല്ലാ സാഹചര്യങ്ങളിലും, ദി
മുമ്പത്തെ ലോക്ക് മൂല്യം തിരികെ നൽകുന്നു.

സ്ട്രിംഗ്സ്
സ്പ്രിന്റ്ഫ്(fmt : സ്ട്രിംഗ്, ...): സ്ട്രിംഗ്
എക്‌സ്‌പ്രഷനുകളുടെ മൂല്യങ്ങൾ ഫോർമാറ്റ് ചെയ്യുന്നതിലൂടെ ലഭിക്കുന്ന സ്‌ട്രിംഗ് നൽകുന്നു
ശേഷം സംഭവിക്കുന്നത് fmt അതനുസരിച്ച് printf(3) ഫോർമാറ്റ് fmt

gsub(str : സ്ട്രിംഗ്, pat : സ്ട്രിംഗ്): സ്ട്രിംഗ്

gsub(str : സ്ട്രിംഗ്, pat : സ്ട്രിംഗ്, repl : സ്ട്രിംഗ്): സ്ട്രിംഗ്
വരുമാനം str എല്ലാ സബ്‌സ്‌ട്രിംഗുകളും പൊരുത്തപ്പെടുന്നു pat ഇല്ലാതാക്കി അല്ലെങ്കിൽ മാറ്റിസ്ഥാപിച്ചു repl,
യഥാക്രമം.

ഉപ(str : സ്ട്രിംഗ്, pat : സ്ട്രിംഗ്): സ്ട്രിംഗ്

ഉപ(str : സ്ട്രിംഗ്, pat : സ്ട്രിംഗ്, repl : സ്ട്രിംഗ്): സ്ട്രിംഗ്
വരുമാനം str ഇടതുവശത്തെ ഉപസ്‌ട്രിംഗ് പൊരുത്തപ്പെടുത്തലിനൊപ്പം pat ഇല്ലാതാക്കി അല്ലെങ്കിൽ മാറ്റിസ്ഥാപിച്ചു repl,
യഥാക്രമം. തുടക്കത്തിലും അവസാനത്തിലും '^', '$' എന്നീ അക്ഷരങ്ങൾ ഉപയോഗിക്കാം,
യഥാക്രമം pat പാറ്റേൺ തുടക്കത്തിലോ അവസാനത്തിലോ നങ്കൂരമിടാൻ str.

substr(str : സ്ട്രിംഗ്, idx : int): സ്ട്രിംഗ്

substr(str : സ്ട്രിംഗ്, idx : int, ലെൻ : int): സ്ട്രിംഗ്
എന്ന ഉപസ്‌ട്രിംഗ് തിരികെ നൽകുന്നു str സ്ഥാനത്ത് ആരംഭിക്കുന്നു idx സ്ട്രിംഗിന്റെ അവസാനം വരെ അല്ലെങ്കിൽ
നീളം ലെൻയഥാക്രമം. സൂചിക 0-ൽ ആരംഭിക്കുന്നു. എങ്കിൽ idx നെഗറ്റീവ് ആണ് അല്ലെങ്കിൽ idx is
യുടെ നീളത്തേക്കാൾ വലുത് str, ഒരു മാരകമായ പിശക് സംഭവിക്കുന്നു. അതുപോലെ, രണ്ടാമത്തേതിൽ
കേസ്, എങ്കിൽ ലെൻ നെഗറ്റീവ് ആണ് അല്ലെങ്കിൽ idx + ലെൻ യുടെ നീളത്തേക്കാൾ വലുതാണ് str, ഒരു മാരകമായ
പിശക് സംഭവിക്കുന്നു.

strcmp(s1 : സ്ട്രിംഗ്, s2 : സ്ട്രിംഗ്): int
സ്റ്റാൻഡേർഡ് സി ഫംഗ്ഷൻ നൽകുന്നു strcmp(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 കോൺക്രീറ്റ് DOT ൽ എഴുതിയിരിക്കുന്നു
ഫോർമാറ്റ്.

ishtml(s : സ്ട്രിംഗ്): int
എങ്കിൽ പൂജ്യമല്ലെങ്കിൽ മാത്രം നൽകുന്നു s ഒരു HTML സ്ട്രിംഗ് ആണ്.

xOf(s : സ്ട്രിംഗ്): സ്ട്രിംഗ്
സ്ട്രിംഗ് തിരികെ നൽകുന്നു "x" എങ്കിൽ s രൂപമുണ്ട്"x,y", എവിടെ രണ്ടും x ഒപ്പം y സംഖ്യാപരമായവയാണ്.

yOf(s : സ്ട്രിംഗ്): സ്ട്രിംഗ്
സ്ട്രിംഗ് തിരികെ നൽകുന്നു "y" എങ്കിൽ s രൂപമുണ്ട്"x,y", എവിടെ രണ്ടും x ഒപ്പം y സംഖ്യാപരമായവയാണ്.

llOf(s : സ്ട്രിംഗ്): സ്ട്രിംഗ്
സ്ട്രിംഗ് തിരികെ നൽകുന്നു "llx,പൊട്ടിച്ചിരിച്ചു" എങ്കിൽ s രൂപമുണ്ട്"llx,പൊട്ടിച്ചിരിച്ചു,urx,യൂറി", എല്ലാം എവിടെ llx,
പൊട്ടിച്ചിരിച്ചു, urx, ഒപ്പം യൂറി സംഖ്യാപരമായവയാണ്.

urOf(s)
urOf(s : സ്ട്രിംഗ്): സ്ട്രിംഗ് സ്ട്രിംഗ് തിരികെ നൽകുന്നു "urx,യൂറി" എങ്കിൽ s രൂപമുണ്ട്
"llx,പൊട്ടിച്ചിരിച്ചു,urx,യൂറി", എല്ലാം എവിടെ llx, പൊട്ടിച്ചിരിച്ചു, urx, ഒപ്പം യൂറി സംഖ്യാപരമായവയാണ്.

sscanf(s : സ്ട്രിംഗ്, fmt : സ്ട്രിംഗ്, ...): int
സ്ട്രിംഗ് സ്കാൻ ചെയ്യുന്നു s, അനുസരിച്ച് മൂല്യങ്ങൾ വേർതിരിച്ചെടുക്കുന്നു sscanf(3) ഫോർമാറ്റ് fmt. ദി
മൂല്യങ്ങൾ ഇനിപ്പറയുന്ന വിലാസങ്ങളിൽ സംഭരിച്ചിരിക്കുന്നു fmt, ഫോം ഉള്ള വിലാസങ്ങൾ &v,
എവിടെ v ശരിയായ തരത്തിലുള്ള ചില പ്രഖ്യാപിത വേരിയബിളാണ്. ഇനങ്ങളുടെ എണ്ണം നൽകുന്നു
വിജയകരമായി സ്കാൻ ചെയ്തു.

രണ്ടായി പിരിയുക(s : സ്ട്രിംഗ്, അർ : ശ്രേണി, സെപ്സ് : സ്ട്രിംഗ്): int

രണ്ടായി പിരിയുക(s : സ്ട്രിംഗ്, അർ : ശ്രേണി): int

ടോക്കണുകൾ(s : സ്ട്രിംഗ്, അർ : ശ്രേണി, സെപ്സ് : സ്ട്രിംഗ്): int

ടോക്കണുകൾ(s : സ്ട്രിംഗ്, അർ : ശ്രേണി): int
ദി രണ്ടായി പിരിയുക ഫംഗ്ഷൻ സ്ട്രിംഗ് തകർക്കുന്നു s വയലുകളിലേക്ക്, അതേസമയം ടോക്കണുകൾ ഫംഗ്ഷൻ
സ്ട്രിംഗിനെ ടോക്കണുകളായി തകർക്കുന്നു. ഒരു ഫീൽഡിൽ എല്ലാ നോൺ-സെപ്പറേറ്റർ പ്രതീകങ്ങളും അടങ്ങിയിരിക്കുന്നു
രണ്ട് സെപ്പറേറ്റർ പ്രതീകങ്ങൾക്കിടയിൽ അല്ലെങ്കിൽ സ്ട്രിംഗിന്റെ ആരംഭം അല്ലെങ്കിൽ അവസാനം. അങ്ങനെ, എ
ഫീൽഡ് ശൂന്യമായ സ്ട്രിംഗായിരിക്കാം. ടോക്കൺ എന്നത് പരമാവധി, ശൂന്യമല്ലാത്ത സബ്‌സ്ട്രിംഗ് അല്ല
ഒരു സെപ്പറേറ്റർ പ്രതീകം അടങ്ങിയിരിക്കുന്നു. എന്നതിൽ നൽകിയിരിക്കുന്നവയാണ് സെപ്പറേറ്റർ പ്രതീകങ്ങൾ
സെപ്സ് വാദം. എങ്കിൽ സെപ്സ് നൽകിയിട്ടില്ല, സ്ഥിര മൂല്യം " \t\n" ആണ്. ദി
ഫംഗ്‌ഷനുകൾ ഫീൽഡുകളുടെയോ ടോക്കണുകളുടെയോ എണ്ണം നൽകുന്നു.

ഫീൽഡുകളും ടോക്കണുകളും ആർഗ്യുമെന്റ് അറേയിൽ സംഭരിച്ചിരിക്കുന്നു. അറേ ആയിരിക്കണം സ്ട്രിംഗ്-
മൂല്യമുള്ളതും, ഒരു സൂചിക തരം വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, അത് ആയിരിക്കണം int. എൻട്രികൾ സൂചികയിലാക്കിയിരിക്കുന്നു
തുടർച്ചയായ പൂർണ്ണസംഖ്യകൾ പ്രകാരം, 0 മുതൽ ആരംഭിക്കുന്നു. അറേയിൽ ഇതിനകം സംഭരിച്ചിരിക്കുന്ന ഏതൊരു മൂല്യവും
ഒന്നുകിൽ തിരുത്തിയെഴുതുക, അല്ലെങ്കിൽ ഫംഗ്‌ഷൻ മടങ്ങിയതിന് ശേഷവും ഉണ്ടായിരിക്കുക.

ഐ / ഒ
അച്ചടിക്കുക(...): ശൂന്യം
പ്രിന്റ് ( exr, ... ) ഓരോ ആർഗ്യുമെന്റിന്റെയും ഒരു സ്ട്രിംഗ് പ്രാതിനിധ്യം പ്രിന്റ് ചെയ്യുന്നു
stdout, തുടർന്ന് ഒരു പുതിയ ലൈൻ.

printf(fmt : സ്ട്രിംഗ്, ...): int

printf(fd : int, fmt : സ്ട്രിംഗ്, ...): int
ഇനിപ്പറയുന്ന എക്സ്പ്രഷനുകളുടെ മൂല്യങ്ങൾ ഫോർമാറ്റ് ചെയ്യുന്നതിലൂടെ ഉണ്ടാകുന്ന സ്ട്രിംഗ് പ്രിന്റ് ചെയ്യുന്നു
fmt അതനുസരിച്ച് printf(3) ഫോർമാറ്റ് fmt. വിജയിക്കുമ്പോൾ 0 നൽകുന്നു. സ്ഥിരസ്ഥിതിയായി, അത്
പ്രിന്റുകൾ ഓണാണ് stdout. ഓപ്ഷണൽ പൂർണ്ണസംഖ്യയാണെങ്കിൽ fd നൽകിയിരിക്കുന്നു, ഔട്ട്പുട്ട് എഴുതിയിരിക്കുന്നു
തുറന്ന സ്ട്രീം ബന്ധപ്പെട്ടിരിക്കുന്നു fd.

സ്കാൻഫ്(fmt : സ്ട്രിംഗ്, ...): int

സ്കാൻഫ്(fd : int, fmt : സ്ട്രിംഗ്, ...): int
അനുസരിച്ച് ഇൻപുട്ട് സ്ട്രീമിൽ നിന്ന് മൂല്യങ്ങളിൽ സ്കാൻ ചെയ്യുന്നു സ്കാൻഫ്(3) ഫോർമാറ്റ് fmt. ദി
മൂല്യങ്ങൾ ഇനിപ്പറയുന്ന വിലാസങ്ങളിൽ സംഭരിച്ചിരിക്കുന്നു fmt, ഫോം ഉള്ള വിലാസങ്ങൾ &v,
എവിടെ v ശരിയായ തരത്തിലുള്ള ചില പ്രഖ്യാപിത വേരിയബിളാണ്. സ്ഥിരസ്ഥിതിയായി, ഇത് വായിക്കുന്നു
stdin. ഓപ്ഷണൽ പൂർണ്ണസംഖ്യയാണെങ്കിൽ fd നൽകിയിരിക്കുന്നു, ഓപ്പൺ സ്ട്രീമിൽ നിന്ന് ഇൻപുട്ട് വായിക്കുന്നു
ബന്ധപ്പെട്ട fd. വിജയകരമായി സ്കാൻ ചെയ്ത ഇനങ്ങളുടെ എണ്ണം നൽകുന്നു.

openF(s : സ്ട്രിംഗ്, t : സ്ട്രിംഗ്): int
ഫയൽ തുറക്കുന്നു s ഒരു I/O സ്ട്രീം ആയി. ചരട് വാദം t ഫയൽ എങ്ങനെയാണെന്ന് വ്യക്തമാക്കുന്നു
തുറന്നു. ആർഗ്യുമെന്റുകൾ സി ഫംഗ്‌ഷന്റെ പോലെയാണ് fopen(3). അത് തിരികെ നൽകുന്നു
സ്ട്രീമിനെ സൂചിപ്പിക്കുന്ന പൂർണ്ണസംഖ്യ, അല്ലെങ്കിൽ പിശകിൽ -1.

പതിവുപോലെ, 0, 1, 2 സ്ട്രീമുകൾ ഇതിനകം തുറന്നിരിക്കുന്നു stdin, stdout, ഒപ്പം stderr,
യഥാക്രമം. മുതലുള്ള gvpr ഉപയോഗിച്ചേക്കാം stdin ഇൻപുട്ട് ഗ്രാഫുകൾ വായിക്കാൻ, ഉപയോക്താവ് ചെയ്യണം
ഈ സ്ട്രീം ഉപയോഗിക്കുന്നത് ഒഴിവാക്കുക.

അടുത്ത് എഫ്(fd : int): int
പൂർണ്ണസംഖ്യ കൊണ്ട് സൂചിപ്പിച്ച ഓപ്പൺ സ്ട്രീം അടയ്ക്കുന്നു fd. സ്ട്രീമുകൾ 0, 1, 2 എന്നിവ ആകാൻ കഴിയില്ല
അടച്ചു. വിജയിക്കുമ്പോൾ 0 നൽകുന്നു.

വായിക്കുക എൽ(fd : int): സ്ട്രിംഗ്
ഇൻപുട്ട് സ്ട്രീമിൽ നിന്ന് വായിച്ച അടുത്ത വരി നൽകുന്നു fd. ഇത് "" ശൂന്യമായ സ്ട്രിംഗ് നൽകുന്നു
ഫയലിന്റെ അവസാനം. റിട്ടേൺ ചെയ്ത സ്‌ട്രിംഗിൽ പുതിയ ലൈൻ പ്രതീകം അവശേഷിക്കുന്നുവെന്നത് ശ്രദ്ധിക്കുക.

മഠം
exp(d : ഇരട്ട): ഇരട്ട
ഇയിലേക്ക് മടങ്ങുന്നു dശക്തി.

ലോഗ്(d : ഇരട്ട): ഇരട്ട
യുടെ സ്വാഭാവിക ലോഗ് തിരികെ നൽകുന്നു d.

ചതുരശ്ര(d : ഇരട്ട): ഇരട്ട
ഇരട്ടയുടെ വർഗ്ഗമൂല്യം നൽകുന്നു d.

മാവെല(d : ഇരട്ട, x : ഇരട്ട): ഇരട്ട
വരുമാനം d വരെ ഉയർത്തി xശക്തി.

cos(d : ഇരട്ട): ഇരട്ട
എന്ന കോസൈൻ തിരികെ നൽകുന്നു d.

പാപം(d : ഇരട്ട): ഇരട്ട
എന്ന പാപം തിരികെ നൽകുന്നു d.

അവൻ2(y : ഇരട്ട, x : ഇരട്ട): ഇരട്ട
യുടെ ആർക്റ്റാൻജന്റ് തിരികെ നൽകുന്നു y / x ശ്രേണിയിൽ -പൈ മുതൽ പൈ വരെ.

MIN(y : ഇരട്ട, x : ഇരട്ട): ഇരട്ട
ഏറ്റവും കുറഞ്ഞ തുക തിരികെ നൽകുന്നു y ഒപ്പം x.

MAX ൽ(y : ഇരട്ട, x : ഇരട്ട): ഇരട്ട
പരമാവധി തിരികെ നൽകുന്നു y ഒപ്പം x.

അസോസിയേറ്റീവ് അറേ
# അർ : int
അറേയിലെ ഘടകങ്ങളുടെ എണ്ണം നൽകുന്നു അർ.

idx in അർ : int
സൂചികയ്ക്കായി ഒരു മൂല്യം സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ 1 നൽകുന്നു idx അറേയിൽ അർ. ഇത് 0 നൽകുന്നു
അല്ലെങ്കിൽ.

സജ്ജമാക്കിയിട്ടില്ല(v : ശ്രേണി, idx): int
സൂചികയിലാക്കിയ ഇനം നീക്കം ചെയ്യുന്നു idx. ഇനം നിലവിലുണ്ടെങ്കിൽ അത് 1 നൽകുന്നു, അല്ലാത്തപക്ഷം 0.

സജ്ജമാക്കിയിട്ടില്ല(v : ശ്രേണി): ശൂന്യം
അറേ വീണ്ടും ആരംഭിക്കുന്നു.

കലര്പ്പായ
പുറത്ത്(v : int): ശൂന്യം
കാരണങ്ങൾ gvpr എക്സിറ്റ് കോഡ് ഉപയോഗിച്ച് പുറത്തുകടക്കാൻ v.

സിസ്റ്റം(cmd : സ്ട്രിംഗ്): int
സ്റ്റാൻഡേർഡ് സി ഫംഗ്ഷൻ നൽകുന്നു സിസ്റ്റം(3). അത് നടപ്പിലാക്കുന്നു cmd ഉപയോക്താവിന്റെ ഷെല്ലിൽ
പരിസ്ഥിതി, ഷെല്ലിന്റെ എക്സിറ്റ് സ്റ്റാറ്റസ് തിരികെ നൽകുന്നു.

റാൻഡ്(): ഇരട്ട
0 നും 1 നും ഇടയിൽ ഒരു വ്യാജ-റാൻഡം ഇരട്ടി നൽകുന്നു.

സരണ്ട്(): int

സരണ്ട്(v : int): int
റാൻഡം നമ്പർ ജനറേറ്ററിനായി ഒരു വിത്ത് സജ്ജമാക്കുന്നു. ഓപ്ഷണൽ ആർഗ്യുമെന്റ് വിത്ത് നൽകുന്നു;
അത് ഒഴിവാക്കിയാൽ, നിലവിലെ സമയം ഉപയോഗിക്കും. മുമ്പത്തെ വിത്ത് മൂല്യം തിരികെ നൽകുന്നു.
സരണ്ട് ഏതെങ്കിലും കോളുകൾക്ക് മുമ്പ് വിളിക്കണം റാൻഡ്.

കളർഎക്സ്(നിറം : സ്ട്രിംഗ്, fmt : സ്ട്രിംഗ്): സ്ട്രിംഗ്
ഒരു വർണ്ണത്തെ ഒരു ഫോർമാറ്റിൽ നിന്ന് മറ്റൊന്നിലേക്ക് വിവർത്തനം ചെയ്യുന്നു. ദി നിറം വാദം ഒരു നിറമായിരിക്കണം
അംഗീകൃത സ്ട്രിംഗ് പ്രാതിനിധ്യങ്ങളിലൊന്നിൽ. ദി fmt മൂല്യം ഒന്നായിരിക്കണം
"RGB", "RGBA", "HSV", അല്ലെങ്കിൽ "HSVA". ഒരു ശൂന്യമായ സ്ട്രിംഗ് പിശകിൽ തിരികെ നൽകി.

ബിൽറ്റ്-ഇൻ വ്യത്യാസങ്ങൾ

gvpr ചില പ്രത്യേക, ബിൽറ്റ്-ഇൻ വേരിയബിളുകൾ നൽകുന്നു, അവയുടെ മൂല്യങ്ങൾ സ്വയമേവ സജ്ജീകരിച്ചിരിക്കുന്നു
gvpr സന്ദർഭം അനുസരിച്ച്. സൂചിപ്പിച്ചതൊഴിച്ചാൽ, ഉപയോക്താവിന് അവരുടെ മൂല്യങ്ങൾ പരിഷ്കരിക്കാൻ കഴിയില്ല.

$ : obj_t
സന്ദർഭത്തെ ആശ്രയിച്ച് നിലവിലെ ഒബ്ജക്റ്റിനെ (നോഡ്, എഡ്ജ്, ഗ്രാഫ്) സൂചിപ്പിക്കുന്നു. ഇതല്ല
ലഭ്യമാണ് ആരംഭിക്കുന്നു or അവസാനിക്കുന്നു ഉപവാക്യങ്ങൾ.

$F : സ്ട്രിംഗ്
നിലവിലെ ഇൻപുട്ട് ഫയലിന്റെ പേരാണ്.

$G : ഗ്രാഫ്_ടി
പ്രോസസ്സ് ചെയ്യുന്ന നിലവിലെ ഗ്രാഫിനെ സൂചിപ്പിക്കുന്നു. ൽ ഇത് ലഭ്യമല്ല ആരംഭിക്കുന്നു or അവസാനിക്കുന്നു
ഉപവാക്യങ്ങൾ.

$NG : ഗ്രാഫ്_ടി
പ്രോസസ്സ് ചെയ്യേണ്ട അടുത്ത ഗ്രാഫിനെ സൂചിപ്പിക്കുന്നു. എങ്കിൽ $NG NULL ആണ്, നിലവിലെ ഗ്രാഫ് $G ആകുന്നു
അവസാന ഗ്രാഫ്. stdin-ൽ നിന്നാണ് ഇൻപുട്ട് വരുന്നതെങ്കിൽ, അവസാന ഗ്രാഫ് ആയിരിക്കില്ല എന്നത് ശ്രദ്ധിക്കുക
ഇൻപുട്ട് പൈപ്പ് അടയ്ക്കുന്നതുവരെ നിർണ്ണയിക്കപ്പെടുന്നു. ൽ ഇത് ലഭ്യമല്ല ആരംഭിക്കുന്നു or അവസാനിക്കുന്നു
ഉപവാക്യങ്ങൾ, അല്ലെങ്കിൽ എങ്കിൽ -n പതാക ഉപയോഗിക്കുന്നു.

$O : ഗ്രാഫ്_ടി
ഔട്ട്പുട്ട് ഗ്രാഫ് സൂചിപ്പിക്കുന്നു. ഗ്രാഫ് ട്രാവേഴ്സലിന് മുമ്പ്, അത് ലക്ഷ്യത്തിലേക്ക് ആരംഭിക്കുന്നു
ഗ്രാഫ്. യാത്രയ്‌ക്ക് ശേഷം ഏതെങ്കിലും END_G പ്രവർത്തനങ്ങൾ, ശൂന്യമല്ലാത്ത ഗ്രാഫിനെയാണ് സൂചിപ്പിക്കുന്നതെങ്കിൽ,
ആ ഗ്രാഫ് ഔട്ട്പുട്ട് സ്ട്രീമിൽ പ്രിന്റ് ചെയ്തിരിക്കുന്നു. ഇതിൽ മാത്രമേ സാധുതയുള്ളൂ N, E ഒപ്പം END_G
ഉപവാക്യങ്ങൾ. ഔട്ട്പുട്ട് ഗ്രാഫ് ഉപയോക്താവ് സജ്ജമാക്കിയേക്കാം.

$T : ഗ്രാഫ്_ടി
നിലവിലെ ടാർഗെറ്റ് ഗ്രാഫ് സൂചിപ്പിക്കുന്നു. ഇത് ഒരു ഉപഗ്രാഫ് ആണ് $G എന്നിവയിൽ മാത്രമേ ലഭ്യമാകൂ
N, E ഒപ്പം END_G ഉപവാക്യങ്ങൾ.

$tgtname : സ്ട്രിംഗ്
ടാർഗെറ്റ് ഗ്രാഫിന്റെ പേര് സൂചിപ്പിക്കുന്നു. സ്ഥിരസ്ഥിതിയായി, ഇത് സജ്ജീകരിച്ചിരിക്കുന്നു "gvpr_result". എങ്കിൽ
എക്സിക്യൂഷൻ സമയത്ത് ഒന്നിലധികം തവണ ഉപയോഗിച്ചു gvpr, എന്നോടൊപ്പം പേര് ചേർക്കും
പൂർണ്ണസംഖ്യ ഈ വേരിയബിൾ ഉപയോക്താവ് സജ്ജമാക്കിയേക്കാം.

$tvroot : നോഡ്_ടി
ഒരു (ഡയറക്ടഡ് അല്ലെങ്കിൽ അൺഡയറക്‌ട്) ആഴം-ആദ്യം അല്ലെങ്കിൽ വീതി-യുടെ ആരംഭ നോഡ് സൂചിപ്പിക്കുന്നു.
ഗ്രാഫിന്റെ ആദ്യ യാത്ര (cf. $tvtype താഴെ). സ്ഥിര മൂല്യം ആണ് NULL വേണ്ടി
ഓരോ ഇൻപുട്ട് ഗ്രാഫും. നൽകിയിരിക്കുന്ന റൂട്ടിലെ ട്രാവസലിന് ശേഷം, മൂല്യമാണെങ്കിൽ $tvroot
മാറിയിരിക്കുന്നു, എന്നതിന്റെ പുതിയ മൂല്യത്തിൽ ഒരു പുതിയ യാത്ര ആരംഭിക്കും $tvroot. കൂടാതെ, സജ്ജമാക്കുക
$tv അടുത്തത് താഴെ.

$tv അടുത്തത് : നോഡ്_ടി
ഒരു (ഡയറക്ടഡ് അല്ലെങ്കിൽ അൺഡയറക്‌ട്) ഡെപ്‌ത്-ആദ്യത്തേയ്‌ക്കായുള്ള അടുത്ത ആരംഭ നോഡ് സൂചിപ്പിക്കുന്നു
ഗ്രാഫിന്റെ വീതി-ആദ്യ യാത്ര (cf. $tvtype താഴെ). ഒരു യാത്ര അവസാനിച്ചാൽ
ഒപ്പം $tvroot പുനഃസജ്ജമാക്കിയിട്ടില്ല, പക്ഷേ $tv അടുത്തത് സജ്ജീകരിച്ചു, പക്ഷേ ഉപയോഗിച്ചിട്ടില്ല, ഇത്
അടുത്ത ചോയിസായി നോഡ് ഉപയോഗിക്കും $tvroot. സ്ഥിര മൂല്യം ആണ് NULL വേണ്ടി
ഓരോ ഇൻപുട്ട് ഗ്രാഫും.

$tvedge : എഡ്ജ്_ടി
BFS, DFS യാത്രകൾക്കായി, ഇത് കറന്റിലേക്ക് എത്താൻ ഉപയോഗിക്കുന്ന അരികിലേക്ക് സജ്ജീകരിച്ചിരിക്കുന്നു
നോഡ് അല്ലെങ്കിൽ എഡ്ജ്. ഒരു യാത്രയുടെ തുടക്കത്തിൽ, അല്ലെങ്കിൽ മറ്റ് യാത്രാ തരങ്ങൾക്കായി, the
മൂല്യം NULL.

$tvtype : tvtype_t
എങ്ങനെയെന്ന് സൂചിപ്പിക്കുന്നു gvpr ഒരു ഗ്രാഫ് കടന്നുപോകുന്നു. ഇതിന് സ്ഥിരമായ മൂല്യങ്ങളിൽ ഒന്ന് മാത്രമേ എടുക്കാൻ കഴിയൂ
താഴെ വിവരിച്ചിരിക്കുന്ന "TV_" എന്ന പ്രിവിക്സിനൊപ്പം. ടിവി_ഫ്ലാറ്റ് സ്ഥിരസ്ഥിതിയാണ്.

അടിസ്ഥാന ഗ്രാഫ് ലൈബ്രറിയിൽ cgraph(3), ഡയറക്‌ട് ചെയ്യാത്ത ഗ്രാഫുകളിലെ അരികുകൾ നൽകിയിട്ടുണ്ട്
ഏകപക്ഷീയമായ ദിശ. ഇതുപോലുള്ള യാത്രകൾക്കായി ഉപയോഗിക്കുന്നു TV_fwd, ആവശ്യമാണ്
സംവിധാനം ചെയ്ത അരികുകൾ.

എ.ആർ.ജി.സി : int
വ്യക്തമാക്കിയ ആർഗ്യുമെന്റുകളുടെ എണ്ണം സൂചിപ്പിക്കുന്നു -a വാദിക്കുന്നു കമാൻഡ്-ലൈൻ ആർഗ്യുമെന്റ്.

എ.ആർ.ജി.വി : സ്ട്രിംഗ് ശ്രേണി
വ്യക്തമാക്കിയ ആർഗ്യുമെന്റുകളുടെ നിരയെ സൂചിപ്പിക്കുന്നു -a വാദിക്കുന്നു കമാൻഡ്-ലൈൻ ആർഗ്യുമെന്റ്. ദി
iഎന്ന വാദം നൽകിയത് ARGV[i].

ബിൽറ്റ്-ഇൻ സ്ഥിരം

നിർവചിച്ചിരിക്കുന്ന നിരവധി പ്രതീകാത്മക സ്ഥിരാങ്കങ്ങളുണ്ട് gvpr.

NULL : obj_t
0 ന് തുല്യമായ ഒരു നൾ ഒബ്ജക്റ്റ് റഫറൻസ്.

ടിവി_ഫ്ലാറ്റ് : tvtype_t
ഏകപക്ഷീയമായി തോന്നുന്ന ക്രമത്തിൽ സന്ദർശിച്ച ഗ്രാഫ് ഒബ്‌ജക്‌റ്റുകൾക്കൊപ്പം ലളിതവും പരന്നതുമായ ഒരു യാത്ര.

TV_ne : tvtype_t
ആദ്യം എല്ലാ നോഡുകളും പിന്നീട് എല്ലാ അരികുകളും സന്ദർശിക്കുന്ന ഒരു യാത്ര.

TV_en : tvtype_t
ആദ്യം എല്ലാ അരികുകളും പിന്നീട് എല്ലാ നോഡുകളും സന്ദർശിക്കുന്ന ഒരു യാത്ര.

TV_dfs : tvtype_t
TV_postdfs : tvtype_t
TV_prepostdfs : tvtype_t
ഡയറക്‌ട്-ആദ്യത്തെ തിരച്ചിൽ ഉപയോഗിച്ച് ഗ്രാഫിന്റെ ഒരു യാത്ര
ഗ്രാഫ്. യാത്ര ചെയ്യാൻ, gvpr യുടെ മൂല്യം പരിശോധിക്കും $tvroot. ഇതിന് ഉണ്ടെങ്കിൽ
ഇതിന് മുമ്പ് ഉണ്ടായിരുന്ന അതേ മൂല്യം (ആരംഭത്തിൽ, മുമ്പത്തെ മൂല്യം ആരംഭിക്കുന്നു
ലേക്ക് NULL.), gvpr സന്ദർശിക്കാത്ത ചില നോഡുകൾക്കായി നോക്കുകയും അതിന്റെ കണക്റ്റുചെയ്‌തിരിക്കുന്നതുവഴി സഞ്ചരിക്കുകയും ചെയ്യും
ഘടകം. മറുവശത്ത്, എങ്കിൽ $tvroot മാറിയിരിക്കുന്നു, അതിന്റെ ബന്ധിപ്പിച്ച ഘടകം ചെയ്യും
പര്യടനം നടത്തുക, ഇത് മുമ്പ് സന്ദർശിച്ചിട്ടില്ലെങ്കിൽ അല്ലെങ്കിൽ എങ്കിൽ $tvroot is NULL,
യാത്ര നിർത്തും. ഉപയോഗിക്കുന്നത് ശ്രദ്ധിക്കുക 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.

TV_rev : tvtype_t
TV_postrev : tvtype_t
TV_prepostrev : tvtype_t
ഇനിപ്പറയുന്ന ഗ്രാഫിൽ മാത്രം ഡെപ്ത്-ആദ്യ തിരയൽ ഉപയോഗിച്ച് ഗ്രാഫിന്റെ ഒരു യാത്ര
റിവേഴ്സ് ആർക്കുകൾ. ട്രാവെർസലിനുള്ള വേരുകളുടെ തിരഞ്ഞെടുപ്പ് വിവരിച്ചതിന് സമാനമാണ്
TV_dfs മുകളിൽ. നിർദ്ദിഷ്ട സന്ദർശന ക്രമം TV_rev, TV_postrev
ഒപ്പം TV_prepostrev അനലോഗ് ട്രാവേർസലുകൾ വ്യക്തമാക്കിയതിന് സമാനമാണ്
TV_dfs, TV_postdfs ഒപ്പം TV_prepostdfs.

TV_bfs : tvtype_t
ഗ്രാഫിന്റെ അഗ്രം അവഗണിച്ച് ഗ്രാഫിലെ വീതിയുള്ള ആദ്യ തിരയൽ ഉപയോഗിച്ച് ഗ്രാഫിന്റെ ഒരു യാത്ര
ദിശകൾ. ഇനം ഓണായി കാണുക TV_dfs എന്ന വേഷത്തിന് മുകളിൽ $tvroot.

ഉദാഹരണങ്ങൾ

gvpr -i 'N[color=="നീല"]' file.gv

നീല നിറമുള്ള എല്ലാ നോഡുകളുടെയും നോഡ്-ഇൻഡ്യൂസ്ഡ് സബ്ഗ്രാഫ് സൃഷ്ടിക്കുക.

gvpr -c 'N[color=="blue"]{color = "ചുവപ്പ്"}' file.gv

എല്ലാ നീല നോഡുകളും ചുവപ്പ് ആക്കുക.

ആരംഭിക്കുന്നു { int n, e; int tot_n = 0; int tot_e = 0; }
BEG_G {
n = nNodes($G);
e = nEdges($G);
printf ("%d നോഡുകൾ %d അരികുകൾ %s\n", n, e, $G.name);
tot_n += n;
tot_e += e;
}
അവസാനിക്കുന്നു { printf ("%d നോഡുകൾ %d അരികുകൾ ആകെ\n", tot_n, tot_e) }

പ്രോഗ്രാമിന്റെ പതിപ്പ് gc.

gvpr -c ""

തുല്യമായ ഇല്ല.

BEG_G { ഗ്രാഫ്_ടി g = ഗ്രാഫ് ("ലയിപ്പിക്കുക", "എസ്"); }
E {
നോഡ്_ടി h = ക്ലോൺ(g,$.head);
നോഡ്_ടി t = ക്ലോൺ(g,$.tail);
എഡ്ജ്_ടി e = എഡ്ജ്(t,h,"");
ഇ.ഭാരം = ഇ.ഭാരം + 1;
}
END_G { $O = g; }

ഇൻപുട്ട് ഗ്രാഫിന്റെ കർശനമായ പതിപ്പ് നിർമ്മിക്കുന്നു, അവിടെ ഒരു എഡ്ജിന്റെ ഭാരം ആട്രിബ്യൂട്ട്
ഇൻപുട്ട് ഗ്രാഫിൽ നിന്ന് എത്ര അരികുകൾ എഡ്ജ് പ്രതിനിധീകരിക്കുന്നു എന്ന് സൂചിപ്പിക്കുന്നു.

ആരംഭിക്കുന്നു {node_t n; int ഡിഗ്രി[]}
E{deg[head]++; ഡിഗ്രി[ടെയിൽ]++; }
END_G {
വേണ്ടി (ഡിഗ്രി[n]) {
printf ("ഡിഗ്രി[%s] = %d\n", n. പേര്, deg[n]);
}
}

അരികുകളുള്ള നോഡുകളുടെ ഡിഗ്രികൾ കണക്കാക്കുന്നു.

ആരംഭിക്കുന്നു {
int i, ഇൻഡന്റ്;
int കണ്ടു [സ്ട്രിംഗ്];
ശൂന്യം prInd (int cnt) {
വേണ്ടി (i = 0; i < cnt; i++) printf (" ");
}
}
BEG_G {

$tvtype = TV_prepostfwd;
$tvroot = നോഡ്($,ARGV[0]);
}
N {
if (കണ്ടു[$.name]) ഇൻഡന്റ്--;
മറ്റാരെങ്കിലും {
prInd(ഇൻഡന്റ്);
അച്ചടിക്കുക ($.പേര്);
കണ്ടു[$.name] = 1;
ഇൻഡന്റ്++;
}
}

ഗ്രാഫിന്റെ ഡെപ്ത്-ആദ്യ ട്രാവേസൽ പ്രിന്റ് ചെയ്യുന്നു, പേരിന്റെ നോഡിൽ നിന്ന് ആരംഭിക്കുന്നു
ARGV[0], ഒരു ഇൻഡന്റ് ലിസ്റ്റായി.

ENVIRONMENT

GVPRPATH
വ്യക്തമാക്കിയ ഫയൽ കണ്ടെത്താൻ തിരയേണ്ട ഡയറക്‌ടറികളുടെ കോളൻ-വേർതിരിക്കപ്പെട്ട ലിസ്റ്റ്
-f ഓപ്ഷൻ. gvpr ഒരു ഡിഫോൾട്ട് ലിസ്റ്റ് ബിൽറ്റ്-ഇൻ ഉണ്ട്. എങ്കിൽ GVPRPATH നിർവചിച്ചിട്ടില്ല
സ്ഥിരസ്ഥിതി പട്ടിക ഉപയോഗിക്കുന്നു. എങ്കിൽ GVPRPATH കോളനിൽ നിന്ന് ആരംഭിക്കുന്നു, ലിസ്റ്റ് രൂപപ്പെടുന്നത്
കൂട്ടിച്ചേർക്കുന്നു GVPRPATH സ്ഥിരസ്ഥിതി പട്ടികയിലേക്ക്. എങ്കിൽ GVPRPATH കോളണിൽ അവസാനിക്കുന്നു, ലിസ്റ്റ് ഇതാണ്
എന്നതിലേക്ക് ഡിഫോൾട്ട് ലിസ്റ്റ് ചേർത്തുകൊണ്ട് രൂപീകരിച്ചു GVPRPATH. അല്ലെങ്കിൽ, GVPRPATH ഇതിനായി ഉപയോഗിക്കുന്നു
പട്ടിക.

വിൻഡോസ് സിസ്റ്റങ്ങളിൽ, മുമ്പത്തെ ഖണ്ഡികയിൽ ``കോളൻ'' പകരം ``അർദ്ധവിരാമം'' നൽകുക.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് gvpr ഓൺലൈനായി ഉപയോഗിക്കുക