gvpr - ອອນລາຍໃນຄລາວ

ໂຄງການ:

NAME

gvpr - graph pattern scanning and processing language

ສະຫຼຸບສັງລວມ

gvpr [-icnqV?] [ -o outfile ] [ -a ໂຕ້ຖຽງ ] [ 'ໂປຣແກມ' | -f ໂປຣແກມ ] [ ໄຟ ]

ລາຍລະອຽດ

gvpr (ທີ່ເອີ້ນວ່າກ່ອນຫນ້ານີ້ gpr) ແມ່ນບັນນາທິການສະຕຣີມກຣາຟທີ່ໄດ້ຮັບແຮງບັນດານໃຈໂດຍ ງຸ່ມ. ມັນຄັດລອກການປ້ອນຂໍ້ມູນ
graphs ກັບຜົນຜະລິດຂອງມັນ, ອາດຈະຫັນປ່ຽນໂຄງສ້າງແລະຄຸນລັກສະນະຂອງເຂົາເຈົ້າ, ການສ້າງໃຫມ່
ກຣາຟ, ຫຼືການພິມຂໍ້ມູນ arbitrary. ຮູບແບບກາຟແມ່ນສະຫນອງໃຫ້ໂດຍ
libcgraph(3). ໂດຍ​ສະ​ເພາະ, gvpr ອ່ານ ແລະຂຽນກາຟໂດຍໃຊ້ພາສາຈຸດ.

ໂດຍພື້ນຖານແລ້ວ, gvpr ຂ້າມເສັ້ນສະແດງແຕ່ລະອັນ, ໝາຍເຖິງ $G, ການ​ຢ້ຽມ​ຢາມ​ແຕ່​ລະ​ຂໍ້​ແລະ​ແຂບ​,
ຈັບຄູ່ມັນກັບກົດລະບຽບການປະຕິບັດ - predicate ສະຫນອງໃຫ້ໃນໂຄງການປ້ອນຂໍ້ມູນ. ກົດລະບຽບແມ່ນ
ປະເມີນຕາມລໍາດັບ. ສໍາລັບແຕ່ລະ predicate ປະເມີນເປັນຄວາມຈິງ, ການປະຕິບັດທີ່ສອດຄ້ອງກັນແມ່ນ
ປະຕິບັດ. ໃນ​ລະ​ຫວ່າງ​ການ​ເດີນ​ທາງ, node ຫຼື​ແຂບ​ໃນ​ປັດ​ຈຸ​ບັນ​ການ​ຢ້ຽມ​ຢາມ​ແມ່ນ​ຫມາຍ​ເຖິງ​ໂດຍ $.

ສໍາລັບແຕ່ລະເສັ້ນສະແດງການປ້ອນຂໍ້ມູນ, ມີເສັ້ນຍ່ອຍເປົ້າໝາຍ, ໝາຍເຖິງ $T, ໃນເບື້ອງຕົ້ນເປົ່າແລະຖືກນໍາໃຊ້
ເພື່ອສະສົມຫນ່ວຍງານທີ່ເລືອກ, ແລະຕາຕະລາງຜົນຜະລິດ, $O, ໃຊ້ສໍາລັບການປຸງແຕ່ງສຸດທ້າຍແລະຫຼັງຈາກນັ້ນ
ຂຽນເພື່ອຜົນຜະລິດ. ໂດຍຄ່າເລີ່ມຕົ້ນ, ກຣາຟຜົນຜະລິດແມ່ນກາຟເປົ້າຫມາຍ. ເສັ້ນສະແດງຜົນ
ສາມາດຖືກກໍານົດໄວ້ໃນໂຄງການຫຼື, ໃນຄວາມຫມາຍຈໍາກັດ, ໃນເສັ້ນຄໍາສັ່ງ.

OPTIONS

ທາງ​ເລືອກ​ດັ່ງ​ຕໍ່​ໄປ​ນີ້​ແມ່ນ​ສະ​ຫນັບ​ສະ​ຫນູນ​:

-a ໂຕ້ຖຽງ
ຊ່ອຍແນ່ ໂຕ້ຖຽງ ຖືກແບ່ງອອກເປັນ tokens ແຍກຊ່ອງຫວ່າງ, ກັບບຸກຄົນ
tokens ມີຢູ່ໃນສະຕຣິງ gvpr ໂຄງ​ການ​ເປັນ ARGV[0],...,ARGV[ARGC-1].
ຕົວອັກສອນຊ່ອງຫວ່າງພາຍໃນສາຍຍ່ອຍທີ່ອ້າງອີງດ່ຽວ ຫຼືຄູ່, ຫຼືນຳໜ້າດ້ວຍ a
backslash, ຖືກລະເລີຍເປັນຕົວແຍກ. ໂດຍທົ່ວໄປ, ຕົວອັກສອນ backslash ປິດ
ຄວາມຫມາຍພິເສດຂອງລັກສະນະຕໍ່ໄປນີ້. ໃຫ້ສັງເກດວ່າ tokens ໄດ້ມາຈາກ
ຫຼາຍ -a ທຸງແມ່ນ concatenated.

-c ໃຊ້ກຣາຟແຫຼ່ງທີ່ມາເປັນກາຟຜົນຜະລິດ.

-i ເອົາສ່ວນຂະຫຍາຍຍ່ອຍທີ່ເກີດຈາກໂນດຂອງກຣາບຜົນຜະລິດໃນບໍລິບົດຂອງ
ເສັ້ນສະແດງຮາກຂອງມັນ.

-o outfile
ເຮັດໃຫ້ກະແສຜົນຜະລິດຖືກຂຽນໃສ່ໄຟລ໌ທີ່ລະບຸໄວ້; ໂດຍຄ່າເລີ່ມຕົ້ນ, ຜົນຜະລິດແມ່ນ
ຂຽນຫາ stdout.

-f ໂປຣແກມ
ໃຊ້ເນື້ອໃນຂອງໄຟລ໌ທີ່ກໍານົດເປັນໂຄງການເພື່ອປະຕິບັດການປ້ອນຂໍ້ມູນ. ຖ້າ
ໂປຣແກມ ມີຕົວອັກສອນຫຍໍ້ໜ້າ, ຊື່ຖືກເອົາເປັນຊື່ເສັ້ນທາງຂອງໄຟລ໌.
ຖ້າບໍ່ດັ່ງນັ້ນ, gvpr ຈະໃຊ້ໄດເລກະທໍລີທີ່ລະບຸໄວ້ໃນຕົວແປສະພາບແວດລ້ອມ
GVPPRPATH ເພື່ອຊອກຫາໄຟລ໌. ຖ້າ -f ບໍ່ໄດ້ໃຫ້, gvpr ຈະ​ນໍາ​ໃຊ້​ທໍາ​ອິດ​ທີ່​ບໍ່​ແມ່ນ
ການໂຕ້ຖຽງທາງເລືອກເປັນໂຄງການ.

-q ປິດຂໍ້ຄວາມເຕືອນ.

-n ປິດການອ່ານກາຟລ່ວງໜ້າ. ໂດຍຄ່າເລີ່ມຕົ້ນ, ຕົວແປ $NG ຖືກຕັ້ງເປັນກາຟຕໍ່ໄປ
ຈະຖືກປຸງແຕ່ງ. ນີ້ຮຽກຮ້ອງໃຫ້ມີການອ່ານເສັ້ນສະແດງຕໍ່ໄປກ່ອນທີ່ຈະດໍາເນີນການ
ກຣາຟປະຈຸບັນ, ເຊິ່ງອາດຈະຕັນຖ້າຫາກວ່າກາຟຕໍ່ໄປໄດ້ຖືກສ້າງຂື້ນພຽງແຕ່ໃນການຕອບສະຫນອງ
ການປະຕິບັດບາງຢ່າງທີ່ກ່ຽວຂ້ອງກັບການປະມວນຜົນຂອງກາຟໃນປະຈຸບັນ.

-V ເຮັດໃຫ້ໂປຣແກມພິມຂໍ້ມູນເວີຊັນ ແລະອອກ.

-? ເຮັດໃຫ້ໂປລແກລມພິມຂໍ້ມູນການນໍາໃຊ້ແລະອອກ.

ດໍາເນີນງານ

operand ດັ່ງ​ຕໍ່​ໄປ​ນີ້​ແມ່ນ​ສະ​ຫນັບ​ສະ​ຫນູນ​:

ໄຟ ຊື່ຂອງໄຟລ໌ທີ່ມີກຣາຟ 1 ຫຼືຫຼາຍກວ່ານັ້ນໃນພາສາຈຸດ. ຖ້າບໍ່ມີ -f ທາງເລືອກ
ໄດ້ຖືກມອບໃຫ້, ຊື່ທໍາອິດຖືກໂຍກຍ້າຍອອກຈາກບັນຊີລາຍຊື່ແລະຖືກນໍາໃຊ້ເປັນໂຄງການປ້ອນຂໍ້ມູນ.
ຖ້າບັນຊີລາຍຊື່ຂອງໄຟລ໌ຫວ່າງເປົ່າ, stdin ຈະຖືກນໍາໃຊ້.

PROGRAMS

A gvpr ໂຄງ​ການ​ປະ​ກອບ​ດ້ວຍ​ບັນ​ຊີ​ລາຍ​ການ​ຂອງ predicate​-action clauses​, ມີ​ຫນຶ່ງ​ໃນ​ຮູບ​ແບບ​:

ເລີ່ມຕົ້ນ { ການປະຕິບັດ }

BEG_G { ການປະຕິບັດ }

N [ ຄາດຄະເນ ] { ການປະຕິບັດ }

E [ ຄາດຄະເນ ] { ການປະຕິບັດ }

END_G { ການປະຕິບັດ }

END { ການປະຕິບັດ }

ໂປລແກລມສາມາດບັນຈຸໄດ້ຫຼາຍທີ່ສຸດຫນຶ່ງຂອງແຕ່ລະ ເລີ່ມຕົ້ນ, END_G ແລະ END ຂໍ້. ມີສາມາດເຮັດໄດ້
ເປັນຈໍານວນໃດກໍ່ຕາມ BEG_G, N ແລະ E ຄໍາຖະແຫຼງການ, ທໍາອິດໃຊ້ກັບກາຟ, ທີສອງກັບ
nodes, ອັນທີສາມກັບຂອບ. ເຫຼົ່ານີ້ຖືກແຍກອອກເປັນທ່ອນໄມ້, ຕັນປະກອບດ້ວຍອັນ
ທາງເລືອກ BEG_G ຄໍາ​ຖະ​ແຫຼງ​ການ​ແລະ​ທັງ​ຫມົດ​ N ແລະ E ຖະແຫຼງການເຖິງຕໍ່ໄປ BEG_G ຖະແຫຼງການ, ຖ້າ
ໃດ. ຄວາມຫມາຍລະດັບສູງສຸດຂອງ a gvpr ໂຄງການແມ່ນ:

ປະເມີນລາຄາ ເລີ່ມຕົ້ນ ຂໍ້, ຖ້າມີ.
ສໍາລັບແຕ່ລະເສັ້ນສະແດງການປ້ອນຂໍ້ມູນ G {
ສໍາລັບແຕ່ລະບລັອກ {
ທີ່ກໍານົດໄວ້ G ເປັນກາຟປະຈຸບັນແລະວັດຖຸປະຈຸບັນ.
ປະເມີນລາຄາ BEG_G ຂໍ້, ຖ້າມີ.
ສໍາລັບແຕ່ລະ node ແລະຂອບໃນ G {
ຕັ້ງ node ຫຼື edge ເປັນວັດຖຸປະຈຸບັນ.
ປະເມີນລາຄາ N or E ຂໍ້, ຕາມຄວາມເຫມາະສົມ.
}
}
ທີ່ກໍານົດໄວ້ G ເປັນວັດຖຸປະຈຸບັນ.
ປະເມີນລາຄາ END_G ຂໍ້, ຖ້າມີ.
}
ປະເມີນລາຄາ END ຂໍ້, ຖ້າມີ.

ການ​ກະທຳ​ຂອງ​ສ ເລີ່ມຕົ້ນ, BEG_G, END_G ແລະ END clauses ແມ່ນປະຕິບັດໃນເວລາທີ່ clauses ແມ່ນ
ການ​ປະ​ເມີນ​ຜົນ​. ສໍາລັບ N or E ຂໍ້ຄວາມ, ບໍ່ວ່າຈະເປັນ predicate ຫຼືການປະຕິບັດອາດຈະຖືກລະເວັ້ນ. ຖ້າມີ
ແມ່ນບໍ່ມີ predicate ກັບການປະຕິບັດ, ການປະຕິບັດແມ່ນປະຕິບັດຢູ່ໃນທຸກ node ຫຼືແຂບ, ເປັນ
ເຫມາະສົມ. ຖ້າບໍ່ມີການດໍາເນີນການແລະການປະເມີນ predicate ກັບຄວາມຈິງ, ທີ່ກ່ຽວຂ້ອງ
node ຫຼື edge ຖືກເພີ່ມໃສ່ກຣາຟເປົ້າຫມາຍ.

ຕັນໄດ້ຖືກປະເມີນຕາມລໍາດັບທີ່ພວກມັນເກີດຂື້ນ. ພາຍໃນທ່ອນໄມ້, ໄດ້ N ຂໍ້
(E clauses, ຕາມລໍາດັບ) ຖືກປະເມີນຢູ່ໃນລໍາດັບທີ່ເກີດຂື້ນ. ຫມາຍເຫດ, ເຖິງແມ່ນວ່າ,
ວ່າພາຍໃນຕັນ, N or E ຂໍ້ຄວາມອາດຈະຖືກ interlaced, ຂຶ້ນກັບຄໍາສັ່ງຂ້າມ.

Predicates ແລະການກະທໍາແມ່ນລໍາດັບຂອງຄໍາຖະແຫຼງໃນພາສາ C ສະຫນັບສະຫນູນໂດຍ
ຕົວຢ່າງ(3) ຫ້ອງສະໝຸດ. ຄວາມແຕກຕ່າງພຽງແຕ່ລະຫວ່າງການຄາດເດົາແລະການກະ ທຳ ແມ່ນວ່າອະດີດ
ຕ້ອງມີປະເພດທີ່ອາດຈະຖືກຕີຄວາມວ່າເປັນຄວາມຈິງຫຼືຜິດ. ນີ້ແມ່ນປົກກະຕິ C
ສົນທິສັນຍາແມ່ນປະຕິບັດຕາມ, ເຊິ່ງມູນຄ່າທີ່ບໍ່ແມ່ນສູນຖືວ່າເປັນຄວາມຈິງ. ນີ້ຈະປະກອບມີ
ສະຕຣິງທີ່ບໍ່ຫວ່າງເປົ່າ ແລະການອ້າງອີງບໍ່ຫວ່າງເປົ່າຕໍ່ກັບຂໍ້, ຂອບ, ແລະອື່ນໆ. ແນວໃດກໍ່ຕາມ, ຖ້າສະຕຣິງສາມາດ
ຖືກແປງເປັນຈໍານວນເຕັມ, ຄ່ານີ້ຖືກນໍາໃຊ້.

ນອກເຫນືອໄປຈາກປະເພດພື້ນຖານ C ປົກກະຕິ (void, int, char, float, ຍາວ, ລົງນາມ ແລະ double),
gvpr ສະຫນອງໃຫ້ string ເປັນຄໍາສັບຄ້າຍຄືສໍາລັບ char*, ແລະປະເພດທີ່ອີງໃສ່ກາຟ node_t, edge_t,
graph_t ແລະ obj_t. ໄດ້ obj_t ປະເພດສາມາດໄດ້ຮັບການເບິ່ງເປັນ supertype ຂອງອື່ນໆ 3 ສີມັງ
ປະເພດ; ປະເພດພື້ນຖານທີ່ຖືກຕ້ອງແມ່ນຮັກສາແບບເຄື່ອນໄຫວ. ນອກຈາກປະເພດພື້ນຖານເຫຼົ່ານີ້, ໄດ້
ພຽງແຕ່ການສະແດງອອກປະເພດອື່ນໆທີ່ສະຫນັບສະຫນູນແມ່ນ (ສະມາຄົມ) arrays.

ຄົງທີ່ປະຕິບັດຕາມໄວຍະກອນ C, ແຕ່ສະຕຣິງອາດຈະຖືກອ້າງອີງດ້ວຍອັນໃດນຶ່ງ "... " or '...'. gvpr
ຍອມຮັບຄຳເຫັນ C++ ເຊັ່ນດຽວກັນກັບຄຳເຫັນປະເພດ cpp. ສໍາລັບອັນສຸດທ້າຍ, ຖ້າເສັ້ນເລີ່ມຕົ້ນດ້ວຍ
ຕົວອັກສອນ '#', ສ່ວນທີ່ເຫຼືອຂອງແຖວຖືກລະເລີຍ.

ຖະແຫຼງການສາມາດເປັນການປະກາດຂອງຟັງຊັນ, ຕົວແປ ຫຼື array, ຫຼື executable.
ຖະແຫຼງການ. ສໍາລັບການປະກາດ, ມີຂອບເຂດດຽວ. ການປະກາດ Array ມີຮູບແບບ:

ປະເພດ array [ type0 ]

ບ່ອນທີ່ type0 ເປັນທາງເລືອກ. ຖ້າມັນຖືກສະຫນອງ, parser ຈະບັງຄັບໃຊ້ array ທັງຫມົດນັ້ນ
subscripts ມີປະເພດທີ່ກໍານົດໄວ້. ຖ້າມັນບໍ່ໄດ້ຖືກສະຫນອງ, ວັດຖຸຂອງທຸກປະເພດສາມາດເປັນ
ໃຊ້ເປັນຕົວໜັງສືຍ່ອຍ. ໃນ C, ຕົວແປແລະ arrays ຕ້ອງໄດ້ຮັບການປະກາດ. ໂດຍສະເພາະ, ເປັນ
ຕົວແປທີ່ບໍ່ໄດ້ປະກາດຈະຖືກຕີຄວາມໝາຍວ່າເປັນຊື່ຂອງຄຸນລັກສະນະຂອງ node, edge ຫຼື
ເສັ້ນສະແດງ, ອີງຕາມສະພາບການ.

ຖະແຫຼງການທີ່ສາມາດປະຕິບັດໄດ້ສາມາດເປັນຫນຶ່ງໃນຕໍ່ໄປນີ້:

{ [ ຄໍາຖະແຫຼງທີ່ ... ] }
ການສະແດງອອກ // ທົ່ວໄປ var = ການສະແດງອອກ
ຖ້າ( ການສະແດງອອກ ) ຄໍາຖະແຫຼງທີ່ [ ອື່ນ ຄໍາຖະແຫຼງທີ່ ]
ສໍາລັບ( ການສະແດງອອກ ; ການສະແດງອອກ ; ການສະແດງອອກ ) ຄໍາຖະແຫຼງທີ່
ສໍາລັບ( array [ var ]) ຄໍາຖະແຫຼງທີ່
forr( array [ var ]) ຄໍາຖະແຫຼງທີ່
ໃນຂະນະທີ່ ( ການສະແດງອອກ ) ຄໍາຖະແຫຼງທີ່
ປ່ຽນ ( ການສະແດງອອກ ) ກໍລະນີ ບົດລາຍງານ
ພັກຜ່ອນ [ ການສະແດງອອກ ]
ດໍາເນີນການຕໍ່ [ ການສະແດງອອກ ]
ການກັບຄືນມາ [ ການສະແດງອອກ ]
ລາຍການໃນວົງເລັບແມ່ນທາງເລືອກ.

ໃນຮູບແບບທີສອງຂອງ ສໍາລັບການ ຖະແຫຼງການ ແລະ forr ຖະແຫຼງການ, ຕົວແປ var ຖືກກໍານົດໃຫ້
ແຕ່ລະຄ່າທີ່ໃຊ້ເປັນດັດຊະນີໃນ array ທີ່ລະບຸ ແລະຈາກນັ້ນເຊື່ອມໂຍງກັນ ຄໍາຖະແຫຼງທີ່ is
ການ​ປະ​ເມີນ​ຜົນ​. ສໍາລັບຕົວເລກແລະດັດຊະນີສະຕຣິງ, ດັດຊະນີແມ່ນກັບຄືນມາໃນການເພີ່ມຂຶ້ນ
(ຫຼຸດລົງ) ລໍາດັບຕົວເລກຫຼື lexicographic ສໍາລັບ ສໍາລັບການ (forr, ຕາມລໍາດັບ). ນີ້ສາມາດຖືກນໍາໃຊ້
ສໍາລັບການຈັດລຽງ.

ຄໍານິຍາມຟັງຊັນສາມາດປາກົດຢູ່ໃນ ເລີ່ມຕົ້ນ ອານຸປະໂຫຍດ.

ການສະແດງອອກປະກອບມີການສະແດງອອກ C ປົກກະຕິ. ການປຽບທຽບສະຕຣິງໂດຍໃຊ້ == ແລະ != ປິ່ນປົວພະຍາດ
ການປະຕິບັດມືຂວາເປັນຮູບແບບສໍາລັບຈຸດປະສົງຂອງການຈັບຄູ່ການສະແດງອອກເປັນປົກກະຕິ. ຮູບແບບ
ການນໍາໃຊ້ ksh(1) ໄຟລ໌ທີ່ກົງກັນ syntax ຮູບແບບ. (ເພື່ອຄວາມສະເໝີພາບຂອງສະຕຣິງງ່າຍໆ, ໃຫ້ໃຊ້ strcmp
function

gvpr ຈະພະຍາຍາມໃຊ້ການສະແດງອອກເປັນສະຕຣິງ ຫຼືຄ່າຕົວເລກຕາມຄວາມເໝາະສົມ. ທັງສອງ
C-like casts ແລະ function templates ຈະເຮັດໃຫ້ການແປງປະຕິບັດ, ຖ້າເປັນໄປໄດ້.

ການສະແດງອອກຂອງປະເພດກາຟິກ (ເຊັ່ນ, graph_t, node_t, edge_t, obj_t) ອາດ​ຈະ​ຕິດ​ຕາມ​ໂດຍ a
ການອ້າງອິງພາກສະຫນາມໃນຮູບແບບຂອງ .ຊື່. ມູນຄ່າຜົນໄດ້ຮັບແມ່ນມູນຄ່າຂອງຄຸນລັກສະນະ
ຊື່ວ່າ ຊື່ ຂອງວັດຖຸທີ່ໃຫ້. ນອກຈາກນັ້ນ, ໃນບາງສະພາບການທີ່ບໍ່ໄດ້ປະກາດ,
ຕົວລະບຸທີ່ບໍ່ໄດ້ດັດແກ້ຖືກເອົາມາເປັນຊື່ຄຸນລັກສະນະ. ໂດຍສະເພາະ, ຕົວກໍານົດດັ່ງກ່າວ
ໝາຍເຖິງຄຸນລັກສະນະຂອງ node ຫຼື edge, ຕາມລຳດັບ, in N ແລະ E ຂໍ້, ແລະ
ເສັ້ນສະແດງໃນປະຈຸບັນໃນ BEG_G ແລະ END_G ຂໍ້.

ຕາມປົກກະຕິໃນ libcgraph(3​) ຕົວ​ແບບ​, ຄຸນ​ລັກ​ສະ​ນະ​ແມ່ນ string​-valued​. ເພີ່ມ​ເຕີມ, gvpr
ສະຫນັບສະຫນູນຄຸນລັກສະນະ pseudo-ບາງອັນຂອງວັດຖຸກາຟ, ບໍ່ຈໍາເປັນ string-valued. ເຫຼົ່ານີ້
ສະທ້ອນເຖິງຄຸນສົມບັດພາຍໃນຂອງວັດຖຸກາຟ ແລະບໍ່ສາມາດກຳນົດໄດ້ໂດຍຜູ້ໃຊ້.

ຫົວຫນ້າ : node_t
ຫົວຂອງແຂບໄດ້.

ຫາງ : node_t
ຫາງຂອງແຂບ.

ຊື່ : string
ຊື່ຂອງຂອບ, node ຫຼືເສັ້ນສະແດງ. ຊື່ຂອງຂອບມີຮູບແບບ "<ຫາງ-
ຊື່>[]", ທີ່ ແມ່ນ "->" ຫຼື "--"ຂຶ້ນກັບ
ບໍ່ວ່າເສັ້ນສະແດງແມ່ນມຸ້ງຫລືບໍ່. ສ່ວນວົງເລັບ [] ພຽງແຕ່ປະກົດວ່າ
ຂອບມີກະແຈທີ່ບໍ່ແມ່ນເລື່ອງເລັກໆນ້ອຍໆ.

ລະດັບປະລິນຍາຕີ : int
indegree ຂອງ node ໄດ້.

ລະດັບປະລິນຍາຕີ : int
outdegree ຂອງ node ໄດ້.

degree : int
ລະດັບຂອງ node ໄດ້.

ຮາກ : graph_t
ເສັ້ນສະແດງຮາກຂອງວັດຖຸ. ຮາກຂອງເສັ້ນສະແດງຮາກແມ່ນຕົວຂອງມັນເອງ.

ພໍ່ແມ່ : graph_t
ເສັ້ນສະແດງຫຼັກຂອງຫຍໍ້ໜ້າໃດໜຶ່ງ. ຫຼັກຂອງເສັ້ນສະແດງຮາກແມ່ນ NULL

n_ edges : int
ຈໍານວນຂອງຂອບໃນກາຟ

n_nodes : int
ຈໍານວນຂອງ nodes ໃນກາຟ

directed : int
true (ບໍ່ແມ່ນສູນ) ຖ້າກຣາຟຖືກຊີ້

ຢ່າງເຄັ່ງຄັດ : int
true (ບໍ່ແມ່ນສູນ) ຖ້າເສັ້ນສະແດງແມ່ນເຄັ່ງຄັດ

Built-IN FUNCTIONS

ຫນ້າທີ່ຕໍ່ໄປນີ້ແມ່ນສ້າງຂຶ້ນໃນ gvpr. ຟັງຊັນເຫຼົ່ານັ້ນກັບຄືນການອ້າງອີງເຖິງກາຟ
ວັດຖຸກັບຄືນມາ NULL ໃນ​ກໍ​ລະ​ນີ​ຂອງ​ຄວາມ​ລົ້ມ​ເຫຼວ​.

ການປ່ຽນແປງເຈາະ ແລະ ຫົວຂໍ້ຍ່ອຍ
graph(s : string, t : string): graph_t
ສ້າງເສັ້ນສະແດງທີ່ມີຊື່ s ແລະປະເພດໃດຖືກລະບຸໂດຍສະຕຣິງ t.
ບໍ່ສົນໃຈກໍລະນີ, ລັກສະນະ U, D, S, N ມີການຕີຄວາມໝາຍແບບບໍ່ມີທິດທາງ,
ຊີ້​ນຳ, ເຂັ້ມ​ງວດ, ແລະ ບໍ່​ເຂັ້ມ​ງວດ, ຕາມ​ລຳ​ດັບ. ຖ້າ t ຫວ່າງເປົ່າ, ມຸ້ງ, ບໍ່ແມ່ນ
ເສັ້ນສະແດງທີ່ເຄັ່ງຄັດແມ່ນຖືກສ້າງຂຶ້ນ.

ຍ່ອຍ(g : graph_t, s : string): graph_t
ສ້າງ subgraph ໃນກາຟ g ທີ່ມີຊື່ s. ຖ້າ subgraph ມີຢູ່ແລ້ວ, ມັນແມ່ນ
ກັບຄືນມາ.

isSubg(g : graph_t, s : string): graph_t
ສົ່ງຄ່າຍ່ອຍໃນກາຟ g ທີ່ມີຊື່ s, ຖ້າມັນມີຢູ່, ຫຼື NULL ຖ້າບໍ່ດັ່ງນັ້ນ.

fstsubg(g : graph_t): graph_t
ຕອບຫຍໍ້ໜ້າທຳອິດໃນກາຟ g, ຫຼື NULL ຖ້າບໍ່ມີ.

nxtsubg(sg : graph_t): graph_t
ຕອບຫຍໍ້ໜ້າຕໍ່ໄປຫຼັງຈາກ sg, ຫຼື NULL.

ແມ່ນໂດຍກົງ(g : graph_t): int
ກັບຄືນຄວາມຈິງຖ້າຫາກວ່າແລະພຽງແຕ່ຖ້າຫາກວ່າ g ແມ່ນມຸ້ງ.

ແມ່ນເຂັ້ມງວດ(g : graph_t): int
ກັບຄືນຄວາມຈິງຖ້າຫາກວ່າແລະພຽງແຕ່ຖ້າຫາກວ່າ g ແມ່ນເຄັ່ງຄັດ.

nNodes(g : graph_t): int
ສົ່ງຄືນຈໍານວນ nodes ໃນ g.

nEdges(g : graph_t): int
ຕອບຈໍານວນຂອບໃນ g.

Nodes
node(sg : graph_t, s : string): node_t
ສ້າງ node ໃນກາຟ g ຂອງຊື່ s. ຖ້າມີໂນດດັ່ງກ່າວຢູ່ແລ້ວ, ມັນຈະຖືກສົ່ງຄືນ.

ໂນດຍ່ອຍ(sg : graph_t, n : node_t): node_t
ໃສ່ node n ເຂົ້າໄປໃນ subgraph g. ສົ່ງຄືນ node.

fstnode(g : graph_t): node_t
ສົ່ງຄືນ node ທໍາອິດໃນກາຟ g, ຫຼື NULL ຖ້າບໍ່ມີ.

nxtnode(n : node_t): node_t
ສົ່ງຄືນ node ຕໍ່ໄປຫຼັງຈາກ n ໃນເສັ້ນສະແດງຮາກ, ຫຼື NULL.

nxtnode_sg(sg : graph_t, n : node_t): node_t
ສົ່ງຄືນ node ຕໍ່ໄປຫຼັງຈາກ n in sg, ຫຼື NULL.

isNode(sg : graph_t, s : string): node_t
ຊອກຫາ node ໃນ (sub)graph sg ຂອງຊື່ s. ຖ້າມີ node ດັ່ງກ່າວ, ມັນຈະຖືກສົ່ງຄືນ.
ຖ້າບໍ່ດັ່ງນັ້ນ, NULL ຖືກສົ່ງຄືນ.

isSubnode(sg : graph_t, n : node_t): int
ສົ່ງຄືນທີ່ບໍ່ແມ່ນສູນຖ້າ node n ຢູ່ໃນ (ຍ່ອຍ). sg, ຫຼືສູນ.

ລະດັບປະລິນຍາຕີ(sg : graph_t, n : node_t): int
ຕອບ indegree ຂອງ node n ໃນ (ຍ່ອຍ). sg.

ຊັ້ນນອກ(sg : graph_t, n : node_t): int
ກັບຄືນ outdegree ຂອງ node n ໃນ (ຍ່ອຍ). sg.

ລະດັບ(sg : graph_t, n : node_t): int
ສົ່ງຄືນລະດັບຂອງ node n ໃນ (ຍ່ອຍ). sg.

ແຄມຂອງ
ແຂບ(t : node_t, h : node_t, s : string): edge_t
ສ້າງຂອບທີ່ມີຂໍ້ຫາງ t, ຫົວ node h ແລະຊື່ s ໃນເສັ້ນສະແດງຮາກ. ຖ້າ
ເສັ້ນສະແດງແມ່ນບໍ່ມີທິດທາງ, ຄວາມແຕກຕ່າງລະຫວ່າງຫົວແລະຫາງແມ່ນບໍ່ສໍາຄັນ.
ຖ້າຂອບດັ່ງກ່າວມີຢູ່ແລ້ວ, ມັນຈະຖືກສົ່ງຄືນ.

edge_sg(sg : graph_t, t : node_t, h : node_t, s : string): edge_t
ສ້າງຂອບທີ່ມີຂໍ້ຫາງ t, ຫົວ node h ແລະຊື່ s ໃນ (ຍ່ອຍ). sg (ແລະທັງ ໝົດ
ກຣາຟແມ່). ຖ້າເສັ້ນສະແດງແມ່ນບໍ່ມີທິດທາງ, ຄວາມແຕກຕ່າງລະຫວ່າງຫົວແລະຫາງ
nodes ແມ່ນບໍ່ສໍາຄັນ. ຖ້າຂອບດັ່ງກ່າວມີຢູ່ແລ້ວ, ມັນຈະຖືກສົ່ງຄືນ.

ຍ່ອຍ(g : graph_t, e : edge_t): edge_t
ໃສ່ຂອບ e ເຂົ້າໄປໃນ subgraph g. ສົ່ງຄືນຂອບ.

isEdge(t : node_t, h : node_t, s : string): edge_t
ຊອກຫາຂອບທີ່ມີຂໍ້ຫາງ t, ຫົວ node h ແລະຊື່ s. ຖ້າເສັ້ນສະແດງແມ່ນ
undirected, ຄວາມແຕກຕ່າງລະຫວ່າງຫົວແລະຫາງແມ່ນບໍ່ສໍາຄັນ. ຖ້າເຊັ່ນນັ້ນ
ແຂບມີຢູ່, ມັນຖືກສົ່ງຄືນ. ຖ້າບໍ່ດັ່ງນັ້ນ, NULL ຖືກສົ່ງຄືນ.

ແມ່ນEdge_sg(sg : graph_t, t : node_t, h : node_t, s : string): edge_t
ຊອກຫາຂອບທີ່ມີຂໍ້ຫາງ t, ຫົວ node h ແລະຊື່ s ໃນ (ຍ່ອຍ). sgທີ່ຢູ່ ຖ້າຫາກວ່າ
ເສັ້ນສະແດງແມ່ນບໍ່ມີທິດທາງ, ຄວາມແຕກຕ່າງລະຫວ່າງຫົວແລະຫາງແມ່ນບໍ່ສໍາຄັນ.
ຖ້າມີຂອບດັ່ງກ່າວ, ມັນຈະຖືກສົ່ງຄືນ. ຖ້າບໍ່ດັ່ງນັ້ນ, NULL ຖືກສົ່ງຄືນ.

isSubedge(g : graph_t, e : edge_t): int
ສົ່ງຄືນທີ່ບໍ່ແມ່ນສູນຖ້າຂອບ e ຢູ່ໃນ (ຍ່ອຍ). sg, ຫຼືສູນ.

fstout(n : node_t): edge_t
ສົ່ງຄືນການ outdge ທໍາອິດຂອງ node n ໃນເສັ້ນສະແດງຮາກ.

fstout_sg(sg : graph_t, n : node_t): edge_t
ສົ່ງຄືນການ outdge ທໍາອິດຂອງ node n ໃນ (ຍ່ອຍ). sg.

nxtout(e : edge_t): edge_t
ກັບຄືນ outdge ຕໍ່ໄປຫຼັງຈາກ e ໃນເສັ້ນສະແດງຮາກ.

nxtout_sg(sg : graph_t, e : edge_t): edge_t
ກັບຄືນ outdge ຕໍ່ໄປຫຼັງຈາກ e ໃນກາຟ sg.

fstin(n : node_t): edge_t
ສົ່ງຄືນ indge ທໍາອິດຂອງ node n ໃນເສັ້ນສະແດງຮາກ.

fstin_sg(sg : graph_t, n : node_t): edge_t
ສົ່ງຄືນ indge ທໍາອິດຂອງ node n ໃນກາຟ sg.

nxtin(e : edge_t): edge_t
ສົ່ງຄືນ indge ຕໍ່ໄປຫຼັງຈາກ e ໃນເສັ້ນສະແດງຮາກ.

nxtin_sg(sg : graph_t, e : edge_t): edge_t
ສົ່ງຄືນ indge ຕໍ່ໄປຫຼັງຈາກ e ໃນກາຟ sg.

fstedge(n : node_t): edge_t
ສົ່ງຄືນຂອບທຳອິດຂອງ node n ໃນເສັ້ນສະແດງຮາກ.

fstedge_sg(sg : graph_t, n : node_t): edge_t
ສົ່ງຄືນຂອບທຳອິດຂອງ node n ໃນກາຟ sg.

nxtedge(e : edge_t, node_t): edge_t
ສົ່ງຄືນຂອບຕໍ່ໄປຫຼັງຈາກ e ໃນເສັ້ນສະແດງຮາກ.

nxtedge_sg(sg : graph_t, e : edge_t, node_t): edge_t
ສົ່ງຄືນຂອບຕໍ່ໄປຫຼັງຈາກ e ໃນກາຟ sg.

opp(e : edge_t, node_t): node_t
ສົ່ງຄືນ node ຢູ່ເທິງຂອບ e ບໍ່ເທົ່າກັບ n. ຕອບ NULL ຖ້າ n ບໍ່ແມ່ນ node ຂອງ
e. ນີ້ສາມາດເປັນປະໂຫຍດໃນເວລາທີ່ການນໍາໃຊ້ fstedge ແລະ nxtedge ເພື່ອ enumerate ປະເທດເພື່ອນບ້ານຂອງ
n.

ເສັ້ນສະແດງ ຂ້າພະເຈົ້າ / O
ຂຽນ(g : graph_t): void
ພິມ g ໃນຮູບແບບຈຸດໃສ່ກະແສຜົນຜະລິດ.

ຂຽນG(g : graph_t, ຊື່ສຽງ : string): void
ພິມ g ໃນຮູບແບບຈຸດເຂົ້າໄປໃນໄຟລ໌ ຊື່ສຽງ.

fwriteG(g : graph_t, fd : int): void
ພິມ g ໃນ​ຮູບ​ແບບ​ຈຸດ​ໃສ່​ການ​ສະ​ຕ​ຣີມ​ເປີດ​ສະ​ແດງ​ໃຫ້​ເຫັນ​ໂດຍ​ຈໍາ​ນວນ​ເຕັມ​ fd.

ອ່ານG(ຊື່ສຽງ : string): graph_t
ສົ່ງຄືນກາຟທີ່ອ່ານຈາກໄຟລ໌ ຊື່ສຽງ. ເສັ້ນສະແດງຄວນຢູ່ໃນຮູບແບບຈຸດ. ຖ້າບໍ່ມີ
ກາ​ຟ​ສາ​ມາດ​ອ່ານ​ໄດ້​, NULL ຖືກສົ່ງຄືນ.

freadG(fd : int): graph_t
ຕອບກຣາບຕໍ່ໄປທີ່ອ່ານຈາກກະແສເປີດ fd. ກັບຄືນ NULL ໃນຕອນທ້າຍຂອງໄຟລ໌.

ເສັ້ນສະແດງ ອື່ນໆ
ລຶບ(g : graph_t, x : obj_t): void
ລຶບວັດຖຸ x ຈາກກາຟ gທີ່ຢູ່ ຖ້າຫາກວ່າ g is NULL, ຟັງຊັນໃຊ້ເສັ້ນສະແດງຮາກຂອງ
xທີ່ຢູ່ ຖ້າຫາກວ່າ x ແມ່ນເສັ້ນສະແດງຫຼືຍ່ອຍ, ມັນຖືກປິດເວັ້ນເສຍແຕ່ x ຖືກລັອກ.

ຢູ່ໃນ(g : graph_t, x : obj_t): int
ກັບຄືນຄວາມຈິງຖ້າຫາກວ່າ x ແມ່ນຢູ່ໃນ subgraph g.

cloneG(g : graph_t, s : string): graph_t
ສ້າງໂຄນຂອງກາຟ g ດ້ວຍ​ຊື່ sທີ່ຢູ່ ຖ້າຫາກວ່າ s ແມ່ນ "", ເສັ້ນສະແດງທີ່ສ້າງຂື້ນມີ
ຊື່ດຽວກັນກັບ g.

clone(g : graph_t, x : obj_t): obj_t
ສ້າງ clone ຂອງວັດຖຸ x ໃນກາຟ g. ໂດຍສະເພາະ, ວັດຖຸໃຫມ່ມີຄືກັນ
ຄຸນລັກສະນະຂອງຊື່/ຄຸນຄ່າ ແລະໂຄງສ້າງເປັນວັດຖຸຕົ້ນສະບັບ. ຖ້າຫາກວ່າວັດຖຸທີ່ມີ
ກະແຈດຽວກັນກັບ x ມີຢູ່ແລ້ວ, ຄຸນລັກສະນະຂອງມັນແມ່ນ overlayed ໂດຍຂອງ x ແລະ
ວັດຖຸຖືກສົ່ງຄືນ. ຖ້າຂອບຖືກໂຄນ, ທັງສອງຈຸດສຸດທ້າຍຈະຖືກໂຄນຢ່າງບໍ່ຊັດເຈນ.
ຖ້າກຣາບໃດນຶ່ງຖືກໂຄນ, ເສັ້ນທັງໝົດ, ຂອບ ແລະເສັ້ນຍ່ອຍຈະຖືກໂຄນຢ່າງບໍ່ຊັດເຈນ. ຖ້າ x
ແມ່ນ​ເສັ້ນ​ສະ​ແດງ​, g ອາດຈະເປັນ NULL, ໃນກໍລະນີນີ້ວັດຖຸ cloned ຈະເປັນຮາກໃຫມ່
ເສັ້ນສະແດງ. ໃນກໍລະນີນີ້, ການໂທແມ່ນເທົ່າກັບ cloneG(x"").

ຄັດລອກ(g : graph_t, x : obj_t): obj_t
ສ້າງສຳເນົາຂອງວັດຖຸ x ໃນກາຟ g, ບ່ອນທີ່ວັດຖຸໃຫມ່ມີຊື່ / ມູນຄ່າດຽວກັນ
ຄຸນລັກສະນະເປັນວັດຖຸຕົ້ນສະບັບ. ຖ້າວັດຖຸທີ່ມີລະຫັດດຽວກັນກັບ x ແລ້ວ
ມີຢູ່, ຄຸນລັກສະນະຂອງມັນແມ່ນ overlayed ໂດຍຂອງ x ແລະວັດຖຸຖືກສົ່ງຄືນ. ຫມາຍ​ເຫດ​
ວ່ານີ້ແມ່ນສໍາເນົາຕື້ນ. ຖ້າ x ແມ່ນກາຟ, ບໍ່ມີຂໍ້, ຂອບ ຫຼືຍ່ອຍຂອງມັນ
ຖືກຄັດລອກໃສ່ໃນກາຟໃຫມ່. ຖ້າ x ແມ່ນແຂບ, ຈຸດສິ້ນສຸດແມ່ນຖືກສ້າງຂຶ້ນຖ້າ
ມີຄວາມຈໍາເປັນ, ແຕ່ພວກເຂົາບໍ່ໄດ້ cloned. ຖ້າ x ແມ່ນ​ເສັ້ນ​ສະ​ແດງ​, g ອາດຈະເປັນ NULL, ໃນກໍລະນີນີ້
ວັດຖຸ cloned ຈະເປັນເສັ້ນສະແດງຮາກໃຫມ່.

ສຳເນົາA(src : obj_t, tgt : obj_t): int
ສຳເນົາຄຸນລັກສະນະຂອງວັດຖຸ src ຄັດຄ້ານ tgt, ຂຽນທັບຄ່າຄຸນລັກສະນະໃດໆ
tgt ໃນເບື້ອງຕົ້ນອາດຈະມີ.

ເຮັດໃຫ້ເກີດ(g : graph_t): void
extends g ຕໍ່ກັບສ່ວນຂະຫຍາຍຍ່ອຍທີ່ເກີດຈາກໂນດໃນເສັ້ນສະແດງຮາກຂອງມັນ.

hasAttr(src : obj_t, ຊື່ : string): int
ສົ່ງຄ່າທີ່ບໍ່ແມ່ນສູນຖ້າວັດຖຸ src ມີຄຸນລັກສະນະທີ່ມີຊື່ ຊື່. ມັນກັບຄືນມາ 0
ຖ້າບໍ່ດັ່ງນັ້ນ.

isAttr(g : graph_t, ປະເພດ : string, ຊື່ : string): int
ສົ່ງຄ່າທີ່ບໍ່ແມ່ນສູນຖ້າຄຸນສົມບັດ ຊື່ ໄດ້​ຖືກ​ກໍາ​ນົດ​ໄວ້​ໃນ g ສໍາລັບວັດຖຸຂອງ
ໄດ້ຮັບ ປະເພດ. ສໍາລັບຂໍ້, ຂອບ, ແລະກຣາຟ, ປະເພດ ຄວນຈະເປັນ "N", "E", ແລະ "G",
ຕາມລໍາດັບ. ມັນກັບຄືນ 0 ຖ້າບໍ່ດັ່ງນັ້ນ.

ຮັບ(src : obj_t, ຊື່ : string): string
ຕອບຄ່າຂອງຄຸນລັກສະນະ ຊື່ ໃນວັດຖຸ src. ນີ້ແມ່ນເປັນປະໂຫຍດສໍາລັບກໍລະນີເຫຼົ່ານັ້ນ
ໃນເວລາທີ່ ຊື່ ຂັດແຍ້ງກັບຄໍາຫນຶ່ງເຊັ່ນ "ຫົວ" ຫຼື "ຮາກ". ຖ້າ
ຄຸນ​ລັກ​ສະ​ນະ​ຍັງ​ບໍ່​ທັນ​ໄດ້​ຮັບ​ການ​ປະ​ກາດ​ໃນ​ເສັ້ນ​ສະ​ແດງ​, ການ​ທໍາ​ງານ​ຈະ​ເລີ່ມ​ຕົ້ນ​ມັນ​ກັບ​
ຄ່າເລີ່ມຕົ້ນຂອງ "". ເພື່ອຫຼີກເວັ້ນການນີ້, ຫນຶ່ງຄວນໃຊ້ hasAttr or isAttr ຫນ້າທີ່
ເພື່ອກວດເບິ່ງວ່າຄຸນລັກສະນະມີຢູ່.

ຊັບສິນ(src : obj_t, ຊື່ : string, ມູນຄ່າ : string): int
ກໍານົດມູນຄ່າຂອງຄຸນລັກສະນະ ຊື່ ໃນວັດຖຸ src to ມູນຄ່າ. ໃຫ້ຜົນຕອບແທນ 0 ໃນຄວາມສຳເລັດ,
ບໍ່ແມ່ນສູນກ່ຽວກັບຄວາມລົ້ມເຫຼວ. ເບິ່ງ ຮັບ ຂ້າງເທິງ.

getDflt(g : graph_t, ປະເພດ : string, ຊື່ : string): string
ຕອບຄ່າເລີ່ມຕົ້ນຂອງຄຸນລັກສະນະ ຊື່ ໃນວັດຖຸໃນ g ຂອງທີ່ໃຫ້ ປະເພດທີ່ຢູ່ ສໍາລັບ
nodes, ຂອບ, ແລະກຣາຟ, ປະເພດ ຄວນເປັນ "N", "E", ແລະ "G", ຕາມລໍາດັບ. ຖ້າ
ຄຸນ​ລັກ​ສະ​ນະ​ຍັງ​ບໍ່​ທັນ​ໄດ້​ຮັບ​ການ​ປະ​ກາດ​ໃນ​ເສັ້ນ​ສະ​ແດງ​, ການ​ທໍາ​ງານ​ຈະ​ເລີ່ມ​ຕົ້ນ​ມັນ​ກັບ​
ຄ່າເລີ່ມຕົ້ນຂອງ "". ເພື່ອຫຼີກເວັ້ນການນີ້, ຫນຶ່ງຄວນໃຊ້ isAttr ຫນ້າ​ທີ່​ໃນ​ການ​ກວດ​ສອບ​
ວ່າຄຸນລັກສະນະມີຢູ່.

setDflt(g : graph_t, ປະເພດ : string, ຊື່ : string, ມູນຄ່າ : string): int
ກໍານົດຄ່າເລີ່ມຕົ້ນຂອງຄຸນລັກສະນະ ຊື່ to ມູນຄ່າ ໃນວັດຖຸໃນ g ຂອງທີ່ໃຫ້
ປະເພດ. ສໍາລັບຂໍ້, ຂອບ, ແລະກຣາຟ, ປະເພດ ຄວນເປັນ "N", "E", ແລະ "G", ຕາມລໍາດັບ.
ຕອບ 0 ໃນຄວາມສຳເລັດ, ບໍ່ແມ່ນສູນຂອງຄວາມລົ້ມເຫລວ. ເບິ່ງ getDflt ຂ້າງເທິງ.

fstAttr(g : graph_t, ປະເພດ : string): string
ຕອບຊື່ຂອງຄຸນລັກສະນະທໍາອິດຂອງວັດຖຸໃນ g ຂອງທີ່ໃຫ້ ປະເພດທີ່ຢູ່ ສໍາລັບ
nodes, ຂອບ, ແລະກຣາຟ, ປະເພດ ຄວນເປັນ "N", "E", ແລະ "G", ຕາມລໍາດັບ. ຖ້າມີ
ບໍ່ມີຄຸນລັກສະນະ, string "" ຖືກສົ່ງຄືນ.

nxtAttr(g : graph_t, ປະເພດ : string, ຊື່ : string): string
ຕອບຊື່ຂອງຄຸນລັກສະນະຕໍ່ໄປຂອງວັດຖຸໃນ g ຂອງທີ່ໃຫ້ ປະເພດ ຫຼັງຈາກ
ຄຸນລັກສະນະ ຊື່. ການໂຕ້ຖຽງ ຊື່ ຕ້ອງເປັນຊື່ຂອງຄຸນລັກສະນະທີ່ມີຢູ່ແລ້ວ; ມັນ
ໂດຍປົກກະຕິຈະເປັນຄ່າກັບຄືນຂອງການໂທທີ່ຜ່ານມາຫາ fstAttr or nxtAttrທີ່ຢູ່ ສໍາລັບ
nodes, ຂອບ, ແລະກຣາຟ, ປະເພດ ຄວນເປັນ "N", "E", ແລະ "G", ຕາມລໍາດັບ. ຖ້າມີ
ບໍ່ມີຄຸນສົມບັດເຫຼືອໄວ້, string "" ຖືກສົ່ງຄືນ.

compOf(g : graph_t, n : node_t): graph_t
ສົ່ງຄືນອົງປະກອບທີ່ເຊື່ອມຕໍ່ຂອງກາຟ g ປະກອບມີ node n, ເປັນ subgraph ຂອງ
g. subgraph ພຽງແຕ່ປະກອບດ້ວຍ nodes. ຫນຶ່ງສາມາດນໍາໃຊ້ ເຮັດໃຫ້ເກີດ ເພື່ອເພີ່ມຂອບ. ໄດ້
ຟັງຊັນລົ້ມເຫລວແລະກັບຄືນມາ NULL if n ບໍ່ໄດ້ຢູ່ໃນ g. ການເຊື່ອມຕໍ່ແມ່ນອີງໃສ່
ເສັ້ນສະແດງທີ່ບໍ່ມີທິດທາງຂອງ g.

ຊະ​ນິດ​ຂອງ(ວັດຖຸ : obj_t): string
ກັບຄືນຕົວຊີ້ບອກຂອງປະເພດຂອງ ວັດຖຸ. ສໍາລັບ nodes, edges, and graphs, it returns
"N", "E", ແລະ "G", ຕາມລໍາດັບ.

ລັອກ(g : graph_t, v : int): int
ປະຕິບັດການລັອກກຣາຟເທິງກຣາຟຮາກ. ຖ້າຈໍານວນເຕັມ v ເປັນບວກ, ເສັ້ນສະແດງແມ່ນ
ຕັ້ງຄ່າເພື່ອໃຫ້ການໂທໃນອະນາຄົດ ລຶບ ບໍ່​ມີ​ຜົນ​ກະ​ທົບ​ທັນ​ທີ​ທັນ​ໃດ​. ຖ້າ v ແມ່ນສູນ, ໄດ້
ກຣາຟຖືກປົດລັອກ. ຖ້າມີການໂທຫາເພື່ອລຶບກາຟໃນຂະນະທີ່ມັນແມ່ນ
ຖືກລັອກ, ເສັ້ນສະແດງປິດ. ຖ້າ v ແມ່ນທາງລົບ, ບໍ່ມີຫຍັງເຮັດ. ໃນກໍລະນີທັງຫມົດ, ໄດ້
ຄ່າ lock ທີ່ຜ່ານມາຖືກສົ່ງຄືນ.

Strings
ແລ່ນ(fmt : string, ...): string
ຕອບສະຕຣິງທີ່ເປັນຜົນມາຈາກການຈັດຮູບແບບຄ່າຂອງການສະແດງຜົນ
ທີ່​ເກີດ​ຂຶ້ນ​ຫຼັງ​ຈາກ​ນັ້ນ​ fmt ອີງ​ຕາມ​ການ printf(3) ຮູບແບບ fmt

gsub(str : string, pat : string): string

gsub(str : string, pat : string, ແທນ : string): string
ກັບຄືນມາ str ກັບສາຍຍ່ອຍທັງໝົດທີ່ກົງກັນ pat ຖືກລົບຫຼືຖືກແທນທີ່ໂດຍ ແທນ,
ຕາມລໍາດັບ.

ການຍ່ອຍ(str : string, pat : string): string

ການຍ່ອຍ(str : string, pat : string, ແທນ : string): string
ກັບຄືນມາ str ດ້ວຍການຈັບຄູ່ສະຕຣິງຍ່ອຍຊ້າຍສຸດ pat ຖືກລົບຫຼືຖືກແທນທີ່ໂດຍ ແທນ,
ຕາມລໍາດັບ. ຕົວອັກສອນ '^' ແລະ '$' ອາດຈະຖືກນໍາໃຊ້ໃນຕອນຕົ້ນແລະທ້າຍ,
ຕາມລໍາດັບ, ຂອງ pat ຍຶດ​ເອົາ​ຮູບ​ແບບ​ທີ່​ຈະ​ເລີ່ມ​ຕົ້ນ​ຫຼື​ສິ້ນ​ສຸດ​ຂອງ​ str.

ຍ່ອຍ(str : string, idx : int): string

ຍ່ອຍ(str : string, idx : int, len : int): string
ສົ່ງຄ່າຍ່ອຍຂອງ str ເລີ່ມ​ແຕ່​ຕໍາ​ແຫນ່ງ​ idx ໃນຕອນທ້າຍຂອງສາຍຫຼື
ຂອງ​ຄວາມ​ຍາວ​ len, ຕາມລໍາດັບ. ດັດສະນີເລີ່ມຕົ້ນທີ່ 0. ຖ້າ idx ແມ່ນທາງລົບຫຼື idx is
ໃຫຍ່ກວ່າຄວາມຍາວຂອງ str, ຄວາມຜິດພາດຮ້າຍແຮງເກີດຂຶ້ນ. ເຊັ່ນດຽວກັນ, ໃນຄັ້ງທີສອງ
ກໍ​ລະ​ນີ​, ຖ້າ​ຫາກ​ວ່າ​ len ແມ່ນທາງລົບຫຼື idx + len ແມ່ນໃຫຍ່ກວ່າຄວາມຍາວຂອງ str, ເສຍຊີວິດ
ຄວາມ​ຜິດ​ພາດ​ເກີດ​ຂຶ້ນ​.

strcmp(s1 : string, s2 : string): int
ໃຫ້ຟັງຊັນ C ມາດຕະຖານ strcmp(3).

ຄວາມຍາວ(s : string): int
ຕອບຄວາມຍາວຂອງສະຕຣິງ s.

ດັດຊະນີ(s : string, t : string): int

rindex(s : string, t : string): int
ຕອບດັດຊະນີຂອງຕົວອັກສອນໃນສະຕຣິງ s ບ່ອນທີ່ຊ້າຍສຸດ (ຂວາສຸດ) ສໍາເນົາ
ຂອງ string t ສາມາດພົບໄດ້, ຫຼື -1 ຖ້າ t ບໍ່ແມ່ນສາຍຍ່ອຍຂອງ s.

ການແຂ່ງຂັນ(s : string, p : string): int
ຕອບດັດຊະນີຂອງຕົວອັກສອນໃນສະຕຣິງ s ບ່ອນ​ທີ່​ການ​ແຂ່ງ​ຂັນ​ຊ້າຍ​ສຸດ​ຂອງ​ຮູບ​ແບບ​
p ສາມາດພົບໄດ້, ຫຼື -1 ຖ້າບໍ່ມີສາຍຍ່ອຍຂອງ s ກົງກັນ p.

topper(s : string): string
ສົ່ງຄືນເວີຊັນຂອງ s ກັບຕົວອັກສອນທີ່ປ່ຽນເປັນຕົວພິມໃຫຍ່.

ລຸ່ມ(s : string): string
ສົ່ງຄືນເວີຊັນຂອງ s ດ້ວຍຕົວອັກສອນທີ່ປ່ຽນເປັນຕົວພິມນ້ອຍ.

canon(s : string): string
ສົ່ງຄືນເວີຊັນຂອງ s ເໝາະສົມທີ່ຈະໃຊ້ເປັນຕົວລະບຸໃນໄຟລ໌ຈຸດ.

html(g : graph_t, s : string): string
ສົ່ງຄືນສະບັບ `` magic '' ຂອງ s ເປັນສະຕຣິງ HTML. ນີ້ປົກກະຕິແລ້ວຈະຖືກນໍາໃຊ້ເພື່ອ
ແນບປ້າຍຊື່ທີ່ຄ້າຍຄືກັບ HTML ກັບວັດຖຸກຣາຟ. ຈົ່ງຈື່ໄວ້ວ່າສະຕຣິງທີ່ສົ່ງຄືນມີຊີວິດຢູ່ໃນ
g. ໂດຍສະເພາະ, ມັນຈະຖືກປົດປ່ອຍເມື່ອ g ປິດ, ແລະເຮັດຫນ້າທີ່ເປັນສາຍ HTML,
ມັນຕ້ອງໄດ້ໃຊ້ກັບວັດຖຸຂອງ g. ນອກຈາກນັ້ນ, ໃຫ້ສັງເກດວ່າວົງເລັບມຸມ
ວົງຢືມບໍ່ຄວນເປັນສ່ວນຫນຶ່ງຂອງ s. ສິ່ງເຫຼົ່ານີ້ຈະຖືກເພີ່ມຖ້າ g ຖືກຂຽນໄວ້ໃນ DOT ສີມັງ
ຮູບແບບ.

ishtml(s : string): int
ສົ່ງຄືນທີ່ບໍ່ແມ່ນສູນ if ແລະພຽງແຕ່ຖ້າ s ເປັນສະຕຣິງ HTML.

xOf(s : string): string
ຕອບສະຕຣິງ "x"ຖ້າ s ມີ​ຮູບ​ແບບ "x,y", ບ່ອນທີ່ທັງສອງ x ແລະ y ເປັນຕົວເລກ.

yOf(s : string): string
ຕອບສະຕຣິງ "y"ຖ້າ s ມີ​ຮູບ​ແບບ "x,y", ບ່ອນທີ່ທັງສອງ x ແລະ y ເປັນຕົວເລກ.

ລອຟ(s : string): string
ຕອບສະຕຣິງ "llx,ຂີ້ຄ້ານ"ຖ້າ s ມີ​ຮູບ​ແບບ "llx,ຂີ້ຄ້ານ,urx,ury", ບ່ອນທີ່ທັງຫມົດຂອງ llx,
ຂີ້ຄ້ານ, urx, ແລະ ury ເປັນຕົວເລກ.

urOf(s)
urOf(s : string): string ຕອບສະຕຣິງ "urx,ury"ຖ້າ s ມີແບບຟອມ
"llx,ຂີ້ຄ້ານ,urx,ury", ບ່ອນທີ່ທັງຫມົດຂອງ llx, ຂີ້ຄ້ານ, urx, ແລະ ury ເປັນຕົວເລກ.

ສະແກນ(s : string, fmt : string, ...): int
ສະແກນສະຕຣິງ s, ການສະກັດເອົາມູນຄ່າອີງຕາມການ ສະແກນ(3) ຮູບແບບ fmt. ໄດ້
ຄ່າຖືກເກັບໄວ້ໃນທີ່ຢູ່ຕໍ່ໄປນີ້ fmt, ທີ່ຢູ່ທີ່ມີແບບຟອມ &v,
ບ່ອນທີ່ v ແມ່ນບາງຕົວແປທີ່ຖືກປະກາດຂອງປະເພດທີ່ຖືກຕ້ອງ. ຕອບຈໍານວນລາຍການ
ສະແກນສຳເລັດແລ້ວ.

ແບ່ງປັນ(s : string, ມາຮອດ : array, Seps : string): int

ແບ່ງປັນ(s : string, ມາຮອດ : array): int

tokens(s : string, ມາຮອດ : array, Seps : string): int

tokens(s : string, ມາຮອດ : array): int
ໄດ້ ແບ່ງປັນ function breaks string s ເຂົ້າໄປໃນທົ່ງນາ, ໃນຂະນະທີ່ tokens ຫນ້າທີ່
ແຍກສາຍອອກເປັນໂທເຄັນ. ຊ່ອງຂໍ້ມູນປະກອບດ້ວຍຕົວອັກສອນທີ່ບໍ່ແມ່ນຕົວແຍກທັງໝົດ
ລະຫວ່າງສອງຕົວອັກສອນຕົວແຍກ ຫຼືຈຸດເລີ່ມຕົ້ນ ຫຼືຈຸດສິ້ນສຸດຂອງສະຕຣິງ. ດັ່ງນັ້ນ, ກ
ຊ່ອງຂໍ້ມູນອາດຈະເປັນສະຕຣິງຫວ່າງເປົ່າ. token ເປັນ substring ສູງສຸດ, ບໍ່ແມ່ນການຫວ່າງເປົ່າ
ມີຕົວອັກສອນຕົວແຍກ. ຕົວອັກສອນຕົວແຍກແມ່ນໃຫ້ຢູ່ໃນ
Seps ການໂຕ້ຖຽງ. ຖ້າ Seps ບໍ່ໄດ້ສະໜອງໃຫ້, ຄ່າເລີ່ມຕົ້ນແມ່ນ " \t\n". ໄດ້
ຟັງຊັນສົ່ງຄືນຈໍານວນຂອງຊ່ອງຂໍ້ມູນຫຼື tokens.

ຊ່ອງຂໍ້ມູນ ແລະໂທເຄັນຖືກເກັບໄວ້ໃນອາເຣອາກິວເມັນ. array ຕ້ອງເປັນ string-
ມູນຄ່າແລະ, ຖ້າປະເພດດັດສະນີຖືກລະບຸ, ມັນຕ້ອງເປັນ int. ລາຍການຖືກດັດສະນີ
ໂດຍຈຳນວນເຕັມທີ່ຕິດຕໍ່ກັນ, ເລີ່ມຈາກ 0. ຄ່າໃດໆກໍຕາມທີ່ເກັບໄວ້ໃນອາເຣຈະ
ຈະຖືກຂຽນທັບ, ຫຼືຍັງຄົງຢູ່ຫຼັງຈາກຟັງຊັນກັບຄືນມາ.

ຂ້າພະເຈົ້າ / O
ພິມ(...): void
ພິມ( ຕົວຢ່າງ, ... ) ພິມຕົວແທນສະຕຣິງຂອງແຕ່ລະ argument ໃນທາງກັບກັນ
stdout, ຕາມດ້ວຍແຖວໃໝ່.

printf(fmt : string, ...): int

printf(fd : int, fmt : string, ...): int
ພິມສະຕຣິງທີ່ເປັນຜົນມາຈາກການຈັດຮູບແບບຄ່າຂອງການສະແດງຜົນຕໍ່ໄປນີ້
fmt ອີງ​ຕາມ​ການ printf(3) ຮູບແບບ fmt. ຕອບຄືນ 0 ໃນຄວາມສຳເລັດ. ໂດຍຄ່າເລີ່ມຕົ້ນ, ມັນ
ພິມ stdout. ຖ້າຈໍານວນທາງເລືອກ fd ແມ່ນ​ໄດ້​ຮັບ​, ຜົນ​ຜະ​ລິດ​ແມ່ນ​ລາຍ​ລັກ​ອັກ​ສອນ​ກ່ຽວ​ກັບ​ການ​
ເປີດກະແສທີ່ກ່ຽວຂ້ອງກັບ fd.

scanf(fmt : string, ...): int

scanf(fd : int, fmt : string, ...): int
ສະແກນຄ່າຈາກກະແສການປ້ອນຂໍ້ມູນຕາມ scanf(3) ຮູບແບບ fmt. ໄດ້
ຄ່າຖືກເກັບໄວ້ໃນທີ່ຢູ່ຕໍ່ໄປນີ້ fmt, ທີ່ຢູ່ທີ່ມີແບບຟອມ &v,
ບ່ອນທີ່ v ແມ່ນບາງຕົວແປທີ່ຖືກປະກາດຂອງປະເພດທີ່ຖືກຕ້ອງ. ໂດຍຄ່າເລີ່ມຕົ້ນ, ມັນອ່ານຈາກ
stdin. ຖ້າຈໍານວນທາງເລືອກ fd ແມ່ນໃຫ້, ປ້ອນຂໍ້ມູນຖືກອ່ານຈາກກະແສເປີດ
ທີ່ກ່ຽວຂ້ອງກັບ fd. ສົ່ງຄືນຈຳນວນລາຍການທີ່ສະແກນສຳເລັດ.

ເປີດF(s : string, t : string): int
ເປີດໄຟລ໌ s ເປັນ I/O stream. ການໂຕ້ຖຽງສະຕຣິງ t ລະບຸວ່າໄຟລ໌ເປັນແນວໃດ
ເປີດ. ການໂຕ້ຖຽງແມ່ນຄືກັນກັບການທໍາງານຂອງ C fopen(3). ມັນກັບຄືນມາເປັນ
ຈຳນວນເຕັມທີ່ສະແດງເຖິງກະແສ, ຫຼື -1 ຜິດພາດ.

ຕາມປົກກະຕິ, ສາຍ 0, 1 ແລະ 2 ເປີດແລ້ວ stdin, stdout, ແລະ stderr,
ຕາມລໍາດັບ. ນັບຕັ້ງແຕ່ gvpr ອາດຈະໃຊ້ stdin ເພື່ອອ່ານເສັ້ນສະແດງການປ້ອນຂໍ້ມູນ, ຜູ້ໃຊ້ຄວນ
ຫຼີກເວັ້ນການນໍາໃຊ້ນ້ໍານີ້.

ປິດF(fd : int): int
ປິດສະຕຣີມເປີດທີ່ສະແດງດ້ວຍຈຳນວນເຕັມ fd. ກະແສ 0, ​​1 ແລະ 2 ບໍ່ສາມາດເປັນໄດ້
ປິດ. ຕອບຄືນ 0 ໃນຄວາມສຳເລັດ.

ອ່ານL(fd : int): string
ສົ່ງຄືນແຖວຕໍ່ໄປທີ່ອ່ານຈາກກະແສການປ້ອນຂໍ້ມູນ fd. ມັນສົ່ງຄ່າສະຕຣິງຫວ່າງເປົ່າ ""
ໃນຕອນທ້າຍຂອງໄຟລ໌. ໃຫ້ສັງເກດວ່າຕົວອັກສອນແຖວໃຫມ່ຖືກປະໄວ້ໃນສະຕຣິງທີ່ສົ່ງຄືນ.

ຄະນິດສາດ
exp(d : double): double
ກັບຄືນ e ກັບ dພະລັງງານທີ.

log(d : double): double
ສົ່ງຄືນບັນທຶກທໍາມະຊາດຂອງ d.

sqrt(d : double): double
ຕອບຄ່າຮາກທີ່ສອງຂອງສອງເທົ່າ d.

pow(d : double, x : double): double
ກັບຄືນມາ d ຍົກຂຶ້ນມາ xພະລັງງານທີ.

cos(d : double): double
ສົ່ງຄືນ cosine ຂອງ d.

sin(d : double): double
ສົ່ງຄືນ sine ຂອງ d.

atan2(y : double, x : double): double
ສົ່ງຄືນ arctangent ຂອງ y / x ໃນໄລຍະ -pi ກັບ pi.

MIN(y : double, x : double): double
ກັບຄືນຕໍາ່ສຸດທີ່ຂອງ y ແລະ x.

MAX(y : double, x : double): double
ສົ່ງຄືນສູງສຸດຂອງ y ແລະ x.

ສະມາຊິກ ອາເລ
# ມາຮອດ : int
ຕອບຈໍານວນອົງປະກອບໃນ array ມາຮອດ.

idx in ມາຮອດ : int
ຕອບ 1 ຖ້າຄ່າຖືກຕັ້ງໃຫ້ດັດສະນີ idx ໃນ array ໄດ້ ມາຮອດ. ມັນກັບຄືນມາ 0
ຖ້າບໍ່ດັ່ງນັ້ນ.

ກຳ ນົດ(v : array, idx): int
ເອົາລາຍການທີ່ຖືກດັດສະນີໂດຍ idx. ມັນຈະສົ່ງຄືນ 1 ຖ້າລາຍການທີ່ມີຢູ່, 0 ຖ້າບໍ່ດັ່ງນັ້ນ.

ກຳ ນົດ(v : array): void
re-initialize array.

Miscellaneous
ການທ່ອງທ່ຽວ(v : int): void
ສາເຫດ gvpr ເພື່ອອອກດ້ວຍລະຫັດອອກ v.

ລະບົບ(cmd : string): int
ໃຫ້ຟັງຊັນ C ມາດຕະຖານ ລະບົບ(3). ມັນປະຕິບັດ cmd ໃນ shell ຂອງຜູ້ໃຊ້
ສະພາບແວດລ້ອມ, ແລະສົ່ງຄືນສະຖານະທາງອອກຂອງແກະ.

ໄຕ້(): double
ຕອບຄ່າ pseudo-random double ລະຫວ່າງ 0 ແລະ 1.

ໄສ້(): int

ໄສ້(v : int): int
ກໍານົດເມັດພັນສໍາລັບເຄື່ອງກໍາເນີດຕົວເລກແບບສຸ່ມ. ການໂຕ້ຖຽງທາງເລືອກໃຫ້ແກ່ນ;
ຖ້າມັນຖືກລະເວັ້ນ, ເວລາປະຈຸບັນແມ່ນໃຊ້. ມູນຄ່າເມັດກ່ອນຫນ້າຈະຖືກສົ່ງຄືນ.
ໄສ້ ຄວນຈະຖືກໂທຫາກ່ອນທີ່ຈະໂທຫາໃດໆ ໄຕ້.

ສີ(ສີ : string, fmt : string): string
ແປສີຈາກຮູບແບບໜຶ່ງໄປຫາອີກຮູບແບບໜຶ່ງ. ໄດ້ ສີ ການໂຕ້ຖຽງຄວນຈະເປັນສີ
ໃນໜຶ່ງໃນຕົວແທນສະຕຣິງທີ່ຮັບຮູ້. ໄດ້ fmt ຄ່າຄວນເປັນຫນຶ່ງໃນ
"RGB", "RGBA", "HSV", ຫຼື "HSVA". ສະຕຣິງຫວ່າງເປົ່າຖືກສົ່ງຄືນຍ້ອນຄວາມຜິດພາດ.

Built-IN ຄວາມຮັບຜິດຊອບ

gvpr ສະໜອງຕົວແປພິເສດສະເພາະ, ຢູ່ໃນຕົວ, ເຊິ່ງຄ່າຂອງພວກມັນຖືກຕັ້ງໂດຍອັດຕະໂນມັດ
gvpr ຂຶ້ນກັບສະພາບການ. ຍົກເວັ້ນຕາມທີ່ບັນທຶກໄວ້, ຜູ້ໃຊ້ບໍ່ສາມາດແກ້ໄຂຄຸນຄ່າຂອງເຂົາເຈົ້າໄດ້.

$ : obj_t
ໝາຍເຖິງວັດຖຸປະຈຸບັນ (node, edge, graph) ຂຶ້ນກັບບໍລິບົດ. ມັນ​ບໍ່​ແມ່ນ
ມີຢູ່ໃນ ເລີ່ມຕົ້ນ or END ຂໍ້.

$F : string
ແມ່ນຊື່ຂອງໄຟລ໌ປ້ອນຂໍ້ມູນປະຈຸບັນ.

$G : graph_t
ໝາຍເຖິງກຣາຟປັດຈຸບັນກຳລັງປະມວນຜົນ. ມັນບໍ່ມີຢູ່ໃນ ເລີ່ມຕົ້ນ or END
ຂໍ້.

$NG : graph_t
ຫມາຍເຖິງກາຟຕໍ່ໄປທີ່ຈະດໍາເນີນການ. ຖ້າ $NG ແມ່ນ NULL, ເສັ້ນສະແດງປັດຈຸບັນ $G ເປັນ
ເສັ້ນສະແດງສຸດທ້າຍ. ໃຫ້ສັງເກດວ່າຖ້າການປ້ອນຂໍ້ມູນມາຈາກ stdin, ເສັ້ນສະແດງສຸດທ້າຍບໍ່ສາມາດເປັນ
ກໍານົດຈົນກ່ວາທໍ່ວັດສະດຸປ້ອນປິດ. ມັນບໍ່ມີຢູ່ໃນ ເລີ່ມຕົ້ນ or END
ຂໍ້, ຫຼືຖ້າຫາກວ່າ -n ທຸງຖືກໃຊ້.

$O : graph_t
ໝາຍເຖິງເສັ້ນສະແດງຜົນອອກ. ກ່ອນທີ່ຈະຜ່ານເສັ້ນກາຟ, ມັນຖືກເລີ່ມຕົ້ນໄປສູ່ເປົ້າຫມາຍ
ເສັ້ນສະແດງ. ຫຼັງຈາກການເດີນທາງແລະໃດໆ END_G ການປະຕິບັດ, ຖ້າມັນຫມາຍເຖິງເສັ້ນສະແດງທີ່ບໍ່ຫວ່າງເປົ່າ,
ເສັ້ນສະແດງນັ້ນຖືກພິມລົງໃສ່ກະແສຜົນຜະລິດ. ມັນພຽງແຕ່ຖືກຕ້ອງໃນ N, E ແລະ END_G
ຂໍ້. ກຣາຟຜົນຜະລິດອາດຈະຖືກກໍານົດໂດຍຜູ້ໃຊ້.

$T : graph_t
ຫມາຍເຖິງເສັ້ນສະແດງເປົ້າຫມາຍໃນປະຈຸບັນ. ມັນເປັນຍ່ອຍຂອງ $G ແລະສາມາດໃຊ້ໄດ້ພຽງແຕ່ໃນ
N, E ແລະ END_G ຂໍ້.

$tgtname : string
ຫມາຍເຖິງຊື່ຂອງກາຟເປົ້າຫມາຍ. ໂດຍຄ່າເລີ່ມຕົ້ນ, ມັນຖືກກໍານົດເປັນ "gvpr_result"ທີ່ຢູ່ ຖ້າຫາກວ່າ
ໃຊ້ຫຼາຍຄັ້ງໃນລະຫວ່າງການປະຕິບັດ gvpr, ຊື່ຈະຖືກຕໍ່ທ້າຍດ້ວຍ
ຈຳນວນເຕັມ. ຕົວແປນີ້ອາດຈະຖືກຕັ້ງໂດຍຜູ້ໃຊ້.

$tvroot : node_t
ຊີ້ບອກຈຸດເລີ່ມຕົ້ນສຳລັບຄວາມເລິກ (ຊີ້ບອກ ຫຼືບໍ່ໄດ້ຊີ້ທາງ) ຄວາມເລິກກ່ອນ ຫຼືຄວາມກວ້າງ-
ເສັ້ນ​ທາງ​ຜ່ານ​ຄັ້ງ​ທໍາ​ອິດ​ຂອງ​ເສັ້ນ​ສະ​ແດງ (cf. $tvtype ຂ້າງລຸ່ມນີ້). ຄ່າເລີ່ມຕົ້ນແມ່ນ NULL ສໍາລັບການ
ແຕ່ລະເສັ້ນສະແດງຜົນ. ຫຼັງ​ຈາກ​ການ​ເດີນ​ທາງ​ຢູ່​ໃນ​ຮາກ​ທີ່​ໄດ້​ຮັບ​, ຖ້າ​ຫາກ​ວ່າ​ມູນ​ຄ່າ​ຂອງ​ $tvroot
ມີການປ່ຽນແປງ, ຂ້າມໃຫມ່ຈະເລີ່ມຕົ້ນດ້ວຍມູນຄ່າໃຫມ່ຂອງ $tvroot. ນອກຈາກນີ້, ກໍານົດ
$tvnext ຂ້າງລຸ່ມນີ້.

$tvnext : node_t
ຊີ້ບອກຈຸດເລີ່ມຕົ້ນຖັດໄປສຳລັບຄວາມເລິກ (ຊີ້ບອກ ຫຼື ບໍ່ໄດ້ຊີ້ທາງ) ກ່ອນ ຫຼື
ຄວາມກວ້າງ-ຂວາງທຳອິດຂອງກາຟ (ເບິ່ງ. $tvtype ຂ້າງລຸ່ມນີ້). ຖ້າ​ຫາກ​ວ່າ​ການ​ເດີນ​ທາງ​ສໍາ​ເລັດ​ຮູບ​
ແລະ $tvroot ຍັງ​ບໍ່​ທັນ​ໄດ້​ຮັບ​ການ​ປັບ​ແຕ່​ $tvnext ໄດ້ຖືກຕັ້ງໄວ້ແຕ່ບໍ່ໄດ້ໃຊ້, ນີ້
node ຈະຖືກນໍາໃຊ້ເປັນທາງເລືອກຕໍ່ໄປສໍາລັບ $tvroot. ຄ່າເລີ່ມຕົ້ນແມ່ນ NULL ສໍາລັບການ
ແຕ່ລະເສັ້ນສະແດງຜົນ.

$tvedge : edge_t
ສໍາລັບ BFS ແລະ DFS traverses, ນີ້ຖືກກໍານົດເປັນຂອບທີ່ໃຊ້ເພື່ອມາຮອດປະຈຸບັນ
node ຫຼື edge. ໃນຕອນເລີ່ມຕົ້ນຂອງ traversal, ຫຼືສໍາລັບປະເພດ traversal ອື່ນໆ, ໄດ້
ມູນຄ່າແມ່ນ NULL.

$tvtype : tvtype_t
ຊີ້ບອກວິທີການ gvpr ຂ້າມເສັ້ນສະແດງ. ມັນພຽງແຕ່ສາມາດເອົາຫນຶ່ງຂອງຄ່າຄົງທີ່
ດ້ວຍຄຳນຳໜ້າ "TV_" ທີ່ອະທິບາຍໄວ້ຂ້າງລຸ່ມນີ້. TV_flat ເປັນຄ່າເລີ່ມຕົ້ນ.

ໃນຫ້ອງສະຫມຸດກຣາຟທີ່ຕິດພັນ ຖັນ(3), ຂອບໃນກາຟທີ່ບໍ່ມີທິດທາງແມ່ນໄດ້ຮັບ an
ທິດ​ທາງ​ທີ່​ຕົນ​ເອງ​. ນີ້ແມ່ນໃຊ້ສໍາລັບການຂ້າມຜ່ານ, ເຊັ່ນ: TV_fwd, ຮຽກຮ້ອງໃຫ້
ແຄມທາງ.

ARGC : int
ຫມາຍເຖິງຈໍານວນຂອງການໂຕ້ຖຽງທີ່ລະບຸໄວ້ໂດຍ -a ໂຕ້ຖຽງ ການໂຕ້ຖຽງແຖວຄໍາສັ່ງ.

ARGV : string array
ໝາຍເຖິງອາເຣຂອງອາກິວເມັນທີ່ລະບຸໄວ້ໂດຍ -a ໂຕ້ຖຽງ ການໂຕ້ຖຽງແຖວຄໍາສັ່ງ. ໄດ້
iການໂຕ້ຖຽງ th ແມ່ນໃຫ້ໂດຍ ARGV[i].

Built-IN ຄົງທີ່

ມີຫຼາຍຕົວຄົງທີ່ສັນຍາລັກທີ່ກໍານົດໂດຍ gvpr.

NULL : obj_t
ການອ້າງອີງວັດຖຸ null, ເທົ່າກັບ 0.

TV_flat : tvtype_t
ເສັ້ນທາງລຽບງ່າຍ, ຮາບພຽງ, ມີວັດຖຸກຣາຟໄດ້ໄປຢ້ຽມຢາມຕາມລໍາດັບທີ່ເບິ່ງຄືວ່າບໍ່ມັກ.

TV_ne : tvtype_t
ເສັ້ນທາງຜ່ານທີ່ທໍາອິດໄປຢ້ຽມຢາມທັງຫມົດຂອງ nodes, ຫຼັງຈາກນັ້ນທັງຫມົດຂອງແຄມ.

TV_en : tvtype_t
ເສັ້ນທາງຜ່ານທີ່ທໍາອິດໄປຢ້ຽມຢາມທັງຫມົດຂອງແຄມ, ຫຼັງຈາກນັ້ນທັງຫມົດຂອງ nodes.

TV_dfs : tvtype_t
TV_postdfs : tvtype_t
TV_prepostdfs : tvtype_t
ເສັ້ນທາງຜ່ານຂອງກາຟໂດຍໃຊ້ການຄົ້ນຫາຄວາມເລິກຄັ້ງທໍາອິດກ່ຽວກັບພື້ນຖານທີ່ບໍ່ມີທິດທາງ
ເສັ້ນສະແດງ. ເພື່ອ​ເຮັດ​ການ​ຜ່ານ​ແດນ​, gvpr ຈະກວດສອບມູນຄ່າຂອງ $tvroot. ຖ້າ​ຫາກ​ວ່າ​ນີ້​ມີ​
ຄ່າດຽວກັນທີ່ມັນມີມາກ່ອນ (ໃນຕອນເລີ່ມຕົ້ນ, ມູນຄ່າທີ່ຜ່ານມາແມ່ນເລີ່ມຕົ້ນ
to NULL.),, gvpr ພຽງແຕ່ຈະຊອກຫາບາງ node ທີ່ບໍ່ເຂົ້າຊົມແລະຜ່ານການເຊື່ອມຕໍ່ຂອງມັນ
ອົງປະກອບ. ໃນທາງກົງກັນຂ້າມ, ຖ້າ $tvroot ມີການປ່ຽນແປງ, ອົງປະກອບເຊື່ອມຕໍ່ຂອງມັນຈະ
be tours, ສົມມຸດວ່າມັນຍັງບໍ່ທັນໄດ້ໄປຢ້ຽມຢາມກ່ອນຫນ້ານີ້ຫຼື, ຖ້າ $tvroot is NULL, ການ
ການ​ເດີນ​ທາງ​ຈະ​ຢຸດ​ເຊົາ​ການ​. ໃຫ້ສັງເກດວ່າການນໍາໃຊ້ TV_dfs ແລະ $tvroot, ມັນເປັນໄປໄດ້ທີ່ຈະສ້າງ
loop ອັນເປັນນິດ.

ໂດຍຄ່າເລີ່ມຕົ້ນ, ການເດີນທາງຂ້າມແມ່ນເຮັດຕາມຄໍາສັ່ງລ່ວງໜ້າ. ນັ້ນແມ່ນ, node ໄດ້ຖືກໄປຢ້ຽມຢາມກ່ອນ
ທັງ ຫມົດ ຂອງ ແຄມ unvisited ຂອງ ຕົນ. ສໍາລັບ TV_postdfs, ຂອບທີ່ບໍ່ເຂົ້າຊົມທັງໝົດຂອງ node ແມ່ນ
ໄດ້ໄປຢ້ຽມຢາມກ່ອນທີ່ຈະ node ໄດ້. ສໍາລັບ TV_prepostdfs, node ແມ່ນໄດ້ໄປຢ້ຽມຢາມສອງຄັ້ງ, ກ່ອນແລະ
ຫຼັງ​ຈາກ​ທັງ​ຫມົດ​ຂອງ​ແຄມ​ທີ່​ບໍ່​ໄດ້​ຢ້ຽມ​ຢາມ​ຂອງ​ຕົນ​.

TV_fwd : tvtype_t
TV_postfwd : tvtype_t
TV_prepostfwd : tvtype_t
ການຂ້າມຜ່ານຂອງກາຟໂດຍໃຊ້ການຄົ້ນຫາຄວາມເລິກ-ທຳອິດໃນກາຟຕໍ່ໄປນີ້ເທົ່ານັ້ນ
arcs ຕໍ່. ທາງ​ເລືອກ​ຂອງ​ຮາກ​ສໍາ​ລັບ​ການ​ຂ້າມ​ແມ່ນ​ຄື​ກັນ​ກັບ​ການ​ອະ​ທິ​ບາຍ​ສໍາ​ລັບ​ການ​
TV_dfs ຂ້າງເທິງ. ຄໍາສັ່ງທີ່ແຕກຕ່າງກັນຂອງການຢ້ຽມຢາມທີ່ລະບຸໄວ້ໂດຍ TV_fwd, TV_postfwd
ແລະ TV_prepostfwd ແມ່ນຄືກັນກັບທີ່ລະບຸໄວ້ໂດຍ traversals ປຽບທຽບ
TV_dfs, TV_postdfs ແລະ TV_prepostdfs.

TV_rev : tvtype_t
TV_postrev : tvtype_t
TV_prepostrev : tvtype_t
ການຂ້າມຜ່ານຂອງກາຟໂດຍໃຊ້ການຄົ້ນຫາຄວາມເລິກ-ທຳອິດໃນກາຟຕໍ່ໄປນີ້ເທົ່ານັ້ນ
arcs ປີ້ນກັບກັນ. ທາງ​ເລືອກ​ຂອງ​ຮາກ​ສໍາ​ລັບ​ການ​ຂ້າມ​ແມ່ນ​ຄື​ກັນ​ກັບ​ການ​ອະ​ທິ​ບາຍ​ສໍາ​ລັບ​ການ​
TV_dfs ຂ້າງເທິງ. ຄໍາສັ່ງທີ່ແຕກຕ່າງກັນຂອງການຢ້ຽມຢາມທີ່ລະບຸໄວ້ໂດຍ TV_rev, TV_postrev
ແລະ TV_prepostrev ແມ່ນຄືກັນກັບທີ່ລະບຸໄວ້ໂດຍ traversals ປຽບທຽບ
TV_dfs, TV_postdfs ແລະ TV_prepostdfs.

TV_bfs : tvtype_t
ເສັ້ນທາງຜ່ານຂອງກຣາຟໂດຍໃຊ້ການຄົ້ນຫາຄວາມກວ້າງ-ທຳອິດຢູ່ໃນກຣາບບໍ່ສົນໃຈຂອບ
ທິດທາງ. ເບິ່ງລາຍການຢູ່ TV_dfs ຂ້າງເທິງສໍາລັບບົດບາດຂອງ $tvroot.

ຕົວຢ່າງ

gvpr -i 'N[color=="blue"]' file.gv

ສ້າງເສັ້ນຍ່ອຍຂອງ node-induced ຂອງ nodes ທັງໝົດດ້ວຍສີຟ້າ.

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 nodes %d ແຄມຂອງ %s\n", n, e, $G.name);
tot_n += n;
tot_e += e;
}
END { printf ("%d nodes %d ແຄມຂອງ ທັງໝົດ\n", tot_n, tot_e) }

ຮຸ່ນຂອງໂຄງການ gc.

gvpr -c ""

ເທົ່າກັບ ບໍ່.

BEG_G { graph_t g = graph ("ລວມ", "S"); }
E {
node_t h = clone(g,$.head);
node_t t = clone(g,$.tail);
edge_t e = edge(t,h,"");
e. ນໍ້າໜັກ = e. ນໍ້າໜັກ + 1;
}
END_G { $O = g; }

ຜະລິດສະບັບທີ່ເຂັ້ມງວດຂອງເສັ້ນສະແດງການປ້ອນຂໍ້ມູນ, ບ່ອນທີ່ຄຸນລັກສະນະນ້ໍາຫນັກຂອງຂອບ
ຊີ້ບອກຈຳນວນຂອບຈາກກຣາບປ້ອນຂໍ້ມູນທີ່ຂອບສະແດງ.

ເລີ່ມຕົ້ນ {node_t n; int deg[]}
E{deg[ຫົວ]++; deg[ຫາງ]++; }
END_G {
ສໍາລັບການ (deg[n]) {
printf ("deg[%s] = %d\n", n.ຊື່, deg[n]);
}
}

ຄິດໄລ່ລະດັບຂອງ nodes ທີ່ມີຂອບ.

ເລີ່ມຕົ້ນ {
int i, ຫຍໍ້ໜ້າ;
int ເຫັນ[string];
void prInd (int cnt) {
ສໍາລັບການ (i = 0; i < cnt; i++) printf (" ");
}
}
BEG_G {

$tvtype = TV_prepostfwd;
$tvroot = node($,ARGV[0]);
}
N {
if (ເຫັນ[$.name]) ຫຍໍ້ໜ້າ--;
ອື່ນ {
prInd(ຫຍໍ້ໜ້າ);
ພິມ ($.name);
ເຫັນ[$.name] = 1;
ຫຍໍ້ໜ້າ ++;
}
}

ພິມເສັ້ນຜ່ານທາງເລິກ-ທຳອິດຂອງກາຟ, ເລີ່ມຕົ້ນດ້ວຍໂນດທີ່ມີຊື່
ARGV[0], ເປັນລາຍການຫຍໍ້ໜ້າ.

ENVIRONMENT

GVPPRPATH
ລາຍຊື່ໄດເລກະທໍລີທີ່ແຍກອອກດ້ວຍຈໍ້າສອງເມັດທີ່ຈະຊອກຫາເພື່ອຊອກຫາໄຟລ໌ທີ່ລະບຸໄວ້ໂດຍ
ທາງເລືອກ -f. gvpr ມີບັນຊີລາຍຊື່ເລີ່ມຕົ້ນທີ່ສ້າງຂຶ້ນໃນ. ຖ້າ GVPPRPATH ບໍ່ໄດ້ກໍານົດ, ໄດ້
ບັນຊີລາຍຊື່ເລີ່ມຕົ້ນຖືກນໍາໃຊ້. ຖ້າ GVPPRPATH ເລີ່ມຕົ້ນດ້ວຍຈໍ້າສອງເມັດ, ບັນຊີລາຍຊື່ຖືກສ້າງຕັ້ງຂຶ້ນໂດຍ
ເພີ່ມເຕີມ GVPPRPATH ໄປຫາບັນຊີລາຍຊື່ເລີ່ມຕົ້ນ. ຖ້າ GVPPRPATH ສິ້ນສຸດດ້ວຍຈໍ້າສອງເມັດ, ບັນຊີລາຍຊື່ແມ່ນ
ສ້າງ​ຕັ້ງ​ຂຶ້ນ​ໂດຍ​ການ​ຕໍ່​ທ້າຍ​ບັນ​ຊີ​ລາຍ​ການ​ເລີ່ມ​ຕົ້ນ​ທີ່​ GVPPRPATH. ຖ້າບໍ່ດັ່ງນັ້ນ, GVPPRPATH ຖືກນໍາໃຊ້ສໍາລັບການ
ບັນຊີລາຍການ.

ໃນລະບົບ Windows, ແທນທີ່ ``colon'' ດ້ວຍ `` semicolon '' ໃນວັກກ່ອນໜ້າ.

ໃຊ້ gvpr ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net