ນີ້ແມ່ນຄໍາສັ່ງ gvpr ທີ່ສາມາດດໍາເນີນການໄດ້ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີໂດຍໃຊ້ຫນຶ່ງໃນຫຼາຍໆບ່ອນເຮັດວຽກອອນໄລນ໌ຂອງພວກເຮົາເຊັ່ນ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator
ໂຄງການ:
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
