ນີ້ແມ່ນຄໍາສັ່ງ funcalc ທີ່ສາມາດດໍາເນີນການໄດ້ໃນ OnWorks ຜູ້ໃຫ້ບໍລິການໂຮດຕິ້ງຟຣີໂດຍໃຊ້ຫນຶ່ງໃນສະຖານີເຮັດວຽກອອນໄລນ໌ຟຣີຫຼາຍອັນຂອງພວກເຮົາເຊັ່ນ Ubuntu Online, Fedora Online, Windows online emulator ຫຼື MAC OS online emulator
ໂຄງການ:
NAME
Funcalc - ເຄື່ອງຄິດເລກ Funtools (ສຳລັບຕາຕະລາງຄູ່)
ສະຫຼຸບສັງລວມ
funcalc [-n] [-a argstr] [-e expr] [-f file] [-l link] [-p prog] [oname [ຖັນ]]
OPTIONS
-a argstr # arguments ຜູ້ໃຊ້ທີ່ຈະສົ່ງກັບໂຄງການລວບລວມ
-e expr # ການສະແດງອອກ funcalc
-f ໄຟລ໌ # ໄຟລ໌ທີ່ປະກອບດ້ວຍການສະແດງອອກ funcalc
-l libs # libs ເພື່ອເພີ່ມໃສ່ຄໍາສັ່ງເຊື່ອມຕໍ່
-n # ຜົນຜະລິດລະຫັດທີ່ສ້າງຂຶ້ນແທນທີ່ຈະລວບລວມແລະປະຕິບັດ
-p prog # ສ້າງໂຄງການທີ່ມີຊື່, ບໍ່ມີການປະຕິບັດ
-u # ຕາຍຖ້າຕົວແປໃດນຶ່ງບໍ່ໄດ້ຖືກປະກາດ (ຢ່າປະກາດອັດຕະໂນມັດ)
ລາຍລະອຽດ
funcalc ເປັນໂຄງການການຄິດໄລ່ທີ່ອະນຸຍາດໃຫ້ການສະແດງອອກໂດຍຕົນເອງໄດ້ຮັບການກໍ່ສ້າງ,
ລວບລວມ, ແລະປະຕິບັດຢູ່ໃນຖັນໃນຕາຕະລາງ Funtools (ຕາຕະລາງຄູ່ FITS ຫຼືເຫດການດິບ
ໄຟລ໌). ມັນເຮັດວຽກໂດຍການລວມຕົວສະແດງອອກທີ່ສະຫນອງໂດຍຜູ້ໃຊ້ເຂົ້າໃນໂຄງການແມ່ແບບ C, ຈາກນັ້ນ
ການລວບລວມແລະປະຕິບັດໂຄງການ. funcalc expressions ແມ່ນຄໍາຖະແຫຼງ C, ເຖິງແມ່ນວ່າບາງ
ຄວາມງ່າຍດາຍທີ່ສໍາຄັນ (ເຊັ່ນການປະກາດອັດຕະໂນມັດຂອງຕົວແປ) ແມ່ນສະຫນັບສະຫນູນ.
funcalc ການສະແດງອອກສາມາດຖືກລະບຸໄວ້ໃນສາມວິທີ: ໃນເສັ້ນຄໍາສັ່ງໂດຍໃຊ້ -e
[ສະແດງອອກ] ສະຫຼັບ, ໃນໄຟລ໌ໂດຍໃຊ້ -f [ໄຟລ໌] ສະຫຼັບ, ຫຼືຈາກ stdin (ຖ້າບໍ່ແມ່ນ -e
neither -f ຖືກກໍານົດ). ແນ່ນອນ, ໄຟລ໌ທີ່ມີ funcalc ການສະແດງອອກສາມາດອ່ານໄດ້ຈາກ
stdin.
ການຮຽກຮ້ອງຂອງແຕ່ລະຄົນ funcalc ຮຽກຮ້ອງໃຫ້ມີການປ້ອນຂໍ້ມູນຕາຕະລາງ Funtools ທີ່ຈະລະບຸເປັນ
ການໂຕ້ຖຽງແຖວຄໍາສັ່ງທໍາອິດ. ໄຟລ໌ຕາຕະລາງ Funtools ຜົນຜະລິດແມ່ນທາງເລືອກທີສອງ
ການໂຕ້ຖຽງ. ມັນເປັນສິ່ງຈໍາເປັນພຽງແຕ່ຖ້າໄຟລ໌ FITS ກໍາລັງຖືກສ້າງຂື້ນ (ie, ໃນກໍລະນີທີ່
ໄດ້ funcalc expression ພຽງແຕ່ພິມຄ່າ, ບໍ່ມີໄຟລ໌ຜົນຜະລິດທີ່ຈໍາເປັນ). ຖ້າ input ແລະ output
ໄຟລ໌ທັງສອງຖືກລະບຸໄວ້, ການໂຕ້ຖຽງທາງເລືອກທີສາມສາມາດລະບຸລາຍຊື່ຂອງຖັນໄດ້
activate (ການນໍາໃຊ້ FunColumnActivate()). ໃຫ້ສັງເກດວ່າ funcalc ກໍານົດວ່າຈະຫຼືບໍ່
ສ້າງລະຫັດສໍາລັບການຂຽນໄຟລ໌ຜົນຜະລິດໂດຍອີງໃສ່ການມີຫຼືບໍ່ມີຜົນຜະລິດ
ການໂຕ້ຖຽງໄຟລ໌.
A funcalc expression ດໍາເນີນການໃນແຕ່ລະແຖວຂອງຕາຕະລາງແລະປະກອບດ້ວຍຫນຶ່ງຫຼືຫຼາຍກວ່າ C
ຄໍາຖະແຫຼງທີ່ດໍາເນີນການຢູ່ໃນຖັນຂອງແຖວນັ້ນ (ອາດຈະໃຊ້ຕົວແປຊົ່ວຄາວ).
ພາຍໃນການສະແດງອອກ, ການອ້າງອີງແມ່ນເຮັດໃຫ້ຖັນຂອງ ໃນປະຈຸບັນ row ໂດຍໃຊ້ໂຄງສ້າງ C
syntax cur-[colname]>, ເຊັ່ນ cur->x, cur->pha, ແລະອື່ນໆ. ສາມາດກໍານົດຕົວແປທ້ອງຖິ່ນໄດ້.
ການນໍາໃຊ້ C declarations ໃນຕອນຕົ້ນຂອງການສະແດງອອກ, ຫຼືອື່ນໆທີ່ພວກເຂົາເຈົ້າສາມາດກໍານົດໄດ້
ອັດຕະໂນມັດໂດຍ funcalc (ເປັນປະເພດສອງ). ດັ່ງນັ້ນ, ສໍາລັບການຍົກຕົວຢ່າງ, swap ຂອງຖັນ x
ແລະ y ໃນຕາຕະລາງສາມາດປະຕິບັດໄດ້ໂດຍໃຊ້ທັງສອງອັນຕໍ່ໄປນີ້ທຽບເທົ່າ funcalc
ສຳນວນ:
ອຸນຫະພູມສອງເທົ່າ;
temp = cur->x;
cur->x = cur->y;
cur->y = temp;
ຫລື:
temp = cur->x;
cur->x = cur->y;
cur->y = temp;
ເມື່ອການສະແດງອອກນີ້ຖືກປະຕິບັດໂດຍໃຊ້ຄໍາສັ່ງເຊັ່ນ:
funcalc -f swap.expr itest.ev otes.ev
ໄຟລ໌ຜົນໄດ້ຮັບຈະມີມູນຄ່າຂອງຖັນ x ແລະ y swapped.
ໂດຍຄ່າເລີ່ມຕົ້ນ, ປະເພດຂໍ້ມູນຂອງຕົວແປສໍາລັບຖັນແມ່ນຄືກັນກັບປະເພດຂໍ້ມູນຂອງ
ຖັນທີ່ເກັບໄວ້ໃນໄຟລ໌. ນີ້ສາມາດປ່ຽນແປງໄດ້ໂດຍການເພີ່ມ ":[dtype]" ໃສ່ອັນທໍາອິດ
ອ້າງເຖິງຖັນນັ້ນ. ໃນຕົວຢ່າງຂ້າງເທິງ, ເພື່ອບັງຄັບໃຫ້ x ແລະ y ເປັນຜົນຜະລິດເປັນສອງເທົ່າ,
ລະບຸປະເພດ 'D' ຢ່າງຈະແຈ້ງ:
temp = cur->x:D;
cur->x = cur->y:D;
cur->y = temp;
ຕົວລະບຸປະເພດຂໍ້ມູນປະຕິບັດຕາມ syntax ຕາຕະລາງ FITS ມາດຕະຖານສໍາລັບການກໍານົດຖັນໂດຍໃຊ້ TFORM:
· A: ຕົວອັກສອນ ASCII
· B: unsigned char 8-bit
· ຂ້ອຍ: ເຊັນ int 16-bit
· U: unsigned 16-bit int (ບໍ່ແມ່ນມາດຕະຖານ FITS)
· J: ເຊັນ int 32-bit
· V: unsigned 32-bit int (ບໍ່ແມ່ນມາດຕະຖານ FITS)
· E: 32-bit float
· D: 64-bit float
· X: bits (ຮັບການປິ່ນປົວເປັນ array ຂອງ chars)
ຈົ່ງຈື່ໄວ້ວ່າພຽງແຕ່ການອ້າງອິງທໍາອິດກັບຖັນຄວນມີປະເພດຂໍ້ມູນທີ່ຊັດເຈນ
ຕົວລະບຸ.
ແນ່ນອນ, ມັນເປັນສິ່ງສໍາຄັນທີ່ຈະຈັດການປະເພດຂໍ້ມູນຂອງຖັນຢ່າງຖືກຕ້ອງ. ຫນຶ່ງໃນ
ສາເຫດເລື້ອຍໆທີ່ສຸດຂອງຄວາມຜິດພາດໃນ funcalc ການຂຽນໂປລແກລມແມ່ນການໃຊ້ຂໍ້ມູນທີ່ບໍ່ຖືກຕ້ອງ
ພິມສໍາລັບຖັນໃນສະແດງອອກ. ສໍາລັບຕົວຢ່າງ, ການຄິດໄລ່:
dx = (cur->x - cur->y)/(cur->x + cur->y);
ປົກກະຕິແລ້ວຕ້ອງໄດ້ຮັບການປະຕິບັດໂດຍໃຊ້ເລກຄະນິດສາດຈຸດລອຍ. ໃນກໍລະນີທີ່ x ແລະ y
ຖັນແມ່ນຈໍານວນເຕັມ, ນີ້ສາມາດເຮັດໄດ້ໂດຍການອ່ານຄໍລໍາເປັນສອງເທົ່າໂດຍໃຊ້ explicit
ປະເພດສະເພາະ:
dx = (cur->x:D - cur->y:D)/(cur->x + cur->y);
ອີກທາງເລືອກ, ມັນສາມາດເຮັດໄດ້ໂດຍໃຊ້ C type-casting ໃນ expression:
dx = ((double)cur->x - (double)cur->y)/((double)cur->x + (double)cur->y);
ນອກເຫນືອຈາກການເຂົ້າເຖິງຄໍລໍາໃນແຖວປະຈຸບັນ, ການອ້າງອິງຍັງສາມາດເຮັດໄດ້
ທີ່ຜ່ານມາ ແຖວທີ່ໃຊ້ ກ່ອນຫນ້ານີ້[colname]>, ແລະ ຕໍ່ໄປ ແຖວທີ່ໃຊ້ ຕໍ່ໄປ-[colname]>. ໃຫ້ສັງເກດວ່າ
if ກ່ອນຫນ້ານີ້[colname]> ແມ່ນລະບຸໄວ້ໃນ funcalc ການສະແດງອອກ, ແຖວທໍາອິດບໍ່ແມ່ນ
ປຸງແຕ່ງ. ຖ້າ ຕໍ່ໄປ-[colname]> ແມ່ນລະບຸໄວ້ໃນ funcalc ການສະແດງອອກ, ແຖວສຸດທ້າຍ
ບໍ່ໄດ້ປະມວນຜົນ. ດ້ວຍວິທີນີ້, prev ແລະ ຕໍ່ໄປ ແມ່ນຮັບປະກັນສະເໝີເພື່ອຊີ້ໄປຫາແຖວທີ່ຖືກຕ້ອງ.
ຕົວຢ່າງ, ເພື່ອພິມຄ່າຂອງຖັນ x ປັດຈຸບັນ ແລະຖັນ y ທີ່ຜ່ານມາ,
ໃຊ້ຟັງຊັນ C fprintf ໃນ a funcalc ການສະແດງອອກ:
fprintf(stdout, "%d %d\n", cur->x, prev->y);
ສາມາດລະບຸຖັນໃໝ່ໄດ້ໂດຍໃຊ້ອັນດຽວກັນ cur-[colname]> syntax ໂດຍການຕໍ່ທ້າຍຖັນ
ປະເພດ (ແລະຕົວລະບຸ tlmin/tlmax/binsiz ທາງເລືອກ), ແຍກໂດຍຈໍ້າສອງເມັດ. ຍົກຕົວຢ່າງ,
cur->avg:D ຈະກຳນົດຖັນໃໝ່ຂອງປະເພດ double. ຕົວລະບຸປະເພດແມ່ນຄືກັນ
ໃຊ້ຂ້າງເທິງເພື່ອລະບຸປະເພດຂໍ້ມູນໃຫມ່ສໍາລັບຖັນທີ່ມີຢູ່ແລ້ວ.
ຕົວຢ່າງ: ເພື່ອສ້າງ ແລະອອກຖັນໃໝ່ທີ່ເປັນຄ່າສະເລ່ຍຂອງ x ແລະ y
ຖັນ, ຖັນ "avg" ໃຫມ່ສາມາດຖືກກໍານົດ:
cur->avg:D = (cur->x + cur->y)/2.0
ໃຫ້ສັງເກດວ່າສຸດທ້າຍ ';' ບໍ່ຈໍາເປັນສໍາລັບການສະແດງອອກໃນແຖວດຽວ.
ເຊັ່ນດຽວກັນກັບຂໍ້ມູນສະເພາະປະເພດຂໍ້ມູນ FITS TFORM, ຕົວລະບຸປະເພດຂໍ້ມູນຖັນສາມາດນຳໜ້າໄດ້
ດ້ວຍການນັບຕົວເລກເພື່ອກໍານົດອາເຣ, ຕົວຢ່າງ, "10I" ຫມາຍເຖິງ vector ຂອງ 10 ints ສັ້ນ, "2E"
ໝາຍເຖິງການເລື່ອນຄວາມແມ່ນຍໍາສອງອັນ, ແລະອື່ນໆ. ຖັນໃໝ່ພຽງແຕ່ຕ້ອງຖືກກຳນົດເທື່ອດຽວໃນ a
funcalc ການສະແດງອອກ, ຫຼັງຈາກນັ້ນມັນສາມາດຖືກນໍາໃຊ້ໂດຍບໍ່ມີການກໍານົດປະເພດຄືນໃຫມ່. ນີ້
ລວມມີການອ້າງອີງເຖິງອົງປະກອບຂອງຖັນແຖວ:
cur->avg[0]:2D = (cur->x + cur->y)/2.0;
cur->avg[1] = (cur->x - cur->y)/2.0;
ປະເພດຂໍ້ມູນ 'X' (bits) ຖືກປະຕິບັດເປັນ char array ຂອງມິຕິ (numeric_count/8), ie,
16X ຖືກປະມວນຜົນເປັນ 2-byte char array. ແຕ່ລະອົງປະກອບອາເຣ 8-bit ແມ່ນເຂົ້າເຖິງແຍກຕ່າງຫາກ:
cur->stat[0]:16X = 1;
cur->stat[1] = 2;
ທີ່ນີ້, ຖັນ 16-bit ຖືກສ້າງຂຶ້ນດ້ວຍ MSB ຖືກຕັ້ງເປັນ 1 ແລະ LSB ຕັ້ງເປັນ 2.
ໂດຍຄ່າເລີ່ມຕົ້ນ, ແຖວທີ່ປະມວນຜົນທັງໝົດຈະຖືກຂຽນໃສ່ໄຟລ໌ຜົນຜະລິດທີ່ລະບຸໄວ້. ຖ້າທ່ານຕ້ອງການ
ຂ້າມການຂຽນແຖວທີ່ແນ່ນອນ, ພຽງແຕ່ປະຕິບັດຄໍາສັ່ງ C "ສືບຕໍ່" ໃນຕອນທ້າຍຂອງ
funcalc ການສະແດງອອກ, ນັບຕັ້ງແຕ່ການຂຽນແຖວໄດ້ຖືກປະຕິບັດທັນທີຫຼັງຈາກ
ການສະແດງອອກຖືກປະຕິບັດ. ຕົວຢ່າງ, ເພື່ອຂ້າມການຂຽນແຖວທີ່ມີຄ່າສະເລ່ຍເທົ່າກັບ
ຄ່າ x ໃນປັດຈຸບັນ:
cur->avg[0]:2D = (cur->x + cur->y)/2.0;
cur->avg[1] = (cur->x - cur->y)/2.0;
ຖ້າ( cur->avg[0] == cur->x )
ສືບຕໍ່;
ຖ້າບໍ່ມີການໂຕ້ຖຽງໄຟລ໌ຜົນຜະລິດຖືກລະບຸໄວ້ໃນ funcalc ເສັ້ນຄໍາສັ່ງ, ບໍ່ມີໄຟລ໌ຜົນຜະລິດແມ່ນ
ເປີດແລະບໍ່ມີແຖວຂຽນ. ອັນນີ້ມີປະໂຫຍດໃນການສະແດງອອກທີ່ພຽງແຕ່ພິມຜົນຜະລິດ
ຜົນໄດ້ຮັບແທນທີ່ຈະສ້າງໄຟລ໌ໃຫມ່:
fpv = (cur->av3:D-cur->av1:D)/(cur->av1+cur->av2:D+cur->av3);
fbv = cur->av2/(cur->av1+cur->av2+cur->av3);
fpu = ((double)cur->au3-cur->au1)/((double)cur->au1+cur->au2+cur->au3);
fbu = cur->au2/(double)(cur->au1+cur->au2+cur->au3);
fprintf(stdout, "%f\t%f\t%f\t%f\n", fpv, fbv, fpu, fbu);
ໃນຕົວຢ່າງຂ້າງເທິງ, ພວກເຮົາໃຊ້ທັງສອງປະເພດສະເພາະທີ່ຊັດເຈນ (ສໍາລັບຄໍລໍາ "av") ແລະປະເພດ
ການຫລໍ່ (ສໍາລັບຄໍລໍາ "au") ເພື່ອຮັບປະກັນວ່າການດໍາເນີນງານທັງຫມົດແມ່ນປະຕິບັດເປັນສອງເທົ່າ
ຄວາມແມ່ນຍໍາ.
ເມື່ອໄຟລ໌ຜົນຜະລິດຖືກລະບຸ, ຕາຕະລາງການປ້ອນຂໍ້ມູນທີ່ເລືອກຈະຖືກປະມວນຜົນແລະແຖວຜົນຜະລິດ
ຖືກຄັດລອກໃສ່ໄຟລ໌ຜົນຜະລິດ. ໃຫ້ສັງເກດວ່າໄຟລ໌ຜົນຜະລິດສາມາດຖືກກໍານົດເປັນ "stdout" ໃນ
ເພື່ອຂຽນແຖວຜົນຜະລິດໄປຫາຜົນຜະລິດມາດຕະຖານ. ຖ້າການໂຕ້ຖຽງໄຟລ໌ຜົນຜະລິດແມ່ນ
ຜ່ານໄປ, ການໂຕ້ຖຽງທີສາມທາງເລືອກຍັງສາມາດຖືກສົ່ງຜ່ານເພື່ອກໍານົດວ່າຖັນໃດທີ່ຈະດໍາເນີນການ.
ໃນຕາຕະລາງຄູ່ FITS, ບາງຄັ້ງມັນສົມຄວນທີ່ຈະຄັດລອກສ່ວນຂະຫຍາຍ FITS ອື່ນໆທັງໝົດ.
ກັບໄຟລ໌ຜົນຜະລິດເຊັ່ນດຽວກັນ. ອັນນີ້ສາມາດເຮັດໄດ້ໂດຍການໃສ່ເຄື່ອງໝາຍ '+' ໃສ່ຊື່ຂອງ
ສ່ວນຂະຫຍາຍຢູ່ໃນຊື່ໄຟລ໌ທີ່ປ້ອນຂໍ້ມູນ. ເບິ່ງ ມ່ວນ ສໍາລັບຕົວຢ່າງທີ່ກ່ຽວຂ້ອງ.
funcalc ເຮັດວຽກໂດຍການລວມການສະແດງອອກທີ່ລະບຸຜູ້ໃຊ້ເຂົ້າໄປໃນໂຄງການແມ່ແບບ C
ເອີ້ນວ່າ tabcalc.c. ໂຄງການທີ່ສໍາເລັດຫຼັງຈາກນັ້ນໄດ້ຖືກລວບລວມແລະດໍາເນີນການ. ຕົວແປ
ຖະແຫຼງການທີ່ເລີ່ມຕົ້ນ funcalc ການສະແດງອອກແມ່ນຖືກຈັດໃສ່ໃນພາກສ່ວນການປະກາດທ້ອງຖິ່ນ
ຂອງໂຄງການຕົ້ນຕໍຂອງແມ່ແບບ. ສາຍອື່ນໆທັງໝົດແມ່ນຖືກຈັດໃສ່ໃນໂປຣແກຣມຫຼັກຂອງແມ່ແບບ
ວົງການປະມວນຜົນພາຍໃນ. ລາຍລະອຽດອື່ນໆຂອງການຜະລິດໂຄງການແມ່ນການຈັດການອັດຕະໂນມັດ. ສໍາລັບ
ຕົວຢ່າງ, ຕົວລະບຸຖັນຖືກວິເຄາະເພື່ອສ້າງໂຄງສ້າງ C ສໍາລັບການປະມວນຜົນແຖວ, ເຊິ່ງແມ່ນ
ຜ່ານໄປ FunColumnSelect() ແລະການນໍາໃຊ້ໃນ FunTableRowGet(). ຖ້າໃຊ້ຕົວແປທີ່ບໍ່ຮູ້ຈັກ
ໃນການສະແດງອອກ, ສົ່ງຜົນໃຫ້ເກີດຄວາມຜິດພາດການລວບລວມ, ການສ້າງໂຄງການແມ່ນ retried ຫຼັງຈາກ
ການກໍານົດຕົວແປທີ່ບໍ່ຮູ້ຈັກເປັນປະເພດສອງເທົ່າ.
ໂດຍປົກກະຕິ, funcalc ລະຫັດສະແດງອອກຖືກເພີ່ມໃສ່ funcalc ແຖວການປະມວນຜົນ loop. ມັນເປັນໄປໄດ້
ເພື່ອເພີ່ມລະຫັດໃສ່ພາກສ່ວນອື່ນໆຂອງໂຄງການໂດຍການວາງລະຫັດນີ້ຢູ່ໃນຄໍາສັ່ງພິເສດ
ຂອງຮູບແບບ:
[ຊື່ຄໍາສັ່ງ]
... ລະຫັດໄປນີ້ ...
ໃນຕອນທ້າຍ
ຄຳແນະນຳແມ່ນ:
· ທົ່ວໂລກ ເພີ່ມລະຫັດແລະການປະກາດໃນຊ່ອງທົ່ວໂລກ, ກ່ອນທີ່ຈະປົກກະຕິຕົ້ນຕໍ.
· ທ້ອງຖິ່ນ ເພີ່ມການປະກາດ (ແລະລະຫັດ) ພຽງແຕ່ຫຼັງຈາກການປະກາດທ້ອງຖິ່ນໃນຕົ້ນຕໍ
· ກ່ອນທີ່ຈະ ເພີ່ມລະຫັດກ່ອນເຂົ້າຮອບການປະມວນຜົນແຖວຫຼັກ
· ຫຼັງຈາກ ເພີ່ມລະຫັດຫຼັງຈາກອອກຈາກ loop ການປະມວນຜົນແຖວຫຼັກ
ດັ່ງນັ້ນ, ຕໍ່ໄປນີ້ funcalc ການສະແດງຜົນຈະປະກາດຕົວແປທົ່ວໂລກ ແລະສ້າງລາຍການຍ່ອຍ
ໂທພຽງແຕ່ກ່ອນແລະພຽງແຕ່ຫຼັງຈາກ loop ການປະມວນຜົນຕົ້ນຕໍ:
ທົ່ວໂລກ
double v1, v2;
double init(void);
double finish(double v);
ໃນຕອນທ້າຍ
ກ່ອນທີ່ຈະ
v1 = init();
ໃນຕອນທ້າຍ
... ແຖວຂະບວນການ, ດ້ວຍການຄິດໄລ່ໂດຍໃຊ້ v1 ...
ຫຼັງຈາກ
v2 = ສໍາເລັດຮູບ(v1);
ຖ້າ(v2 < 0.0 ){
fprintf(stderr, "ການປະມວນຜົນລົ້ມເຫລວ %g -> %g\n", v1, v2);
ການທ່ອງທ່ຽວ(1)
}
ໃນຕອນທ້າຍ
ປົກກະຕິເຊັ່ນ ໃນມັນ() ແລະ ສໍາເລັດຮູບ() ຂ້າງເທິງແມ່ນຖືກສົ່ງໄປຫາໂຄງການທີ່ສ້າງຂຶ້ນສໍາລັບການເຊື່ອມຕໍ່
ການນໍາໃຊ້ -l [ເຊື່ອມຕໍ່ directives ... ] ສະຫຼັບ. ສະຕຣິງທີ່ລະບຸໄວ້ໂດຍສະວິດນີ້ຈະເປັນ
ເພີ່ມໃສ່ເສັ້ນເຊື່ອມຕໍ່ທີ່ໃຊ້ໃນການກໍ່ສ້າງໂຄງການ (ກ່ອນຫ້ອງສະຫມຸດ funtools). ສໍາລັບ
ຕົວຢ່າງ, ສົມມຸດວ່າ ໃນມັນ() ແລະ ສໍາເລັດຮູບ() ຢູ່ໃນຫ້ອງສະຫມຸດ libmysubs.a ໃນ
/opt/special/lib directory, ໃຊ້:
funcalc -l "-L/opt/special/lib -lmysubs" ...
argument ຂອງຜູ້ໃຊ້ສາມາດຖືກສົ່ງກັບໂຄງການ funcalc ທີ່ລວບລວມໂດຍໃຊ້ string argument ໄປຫາ the
ສະຫຼັບ "-a". ສະຕຣິງຄວນມີອາກິວເມັນຂອງຜູ້ໃຊ້ທັງໝົດ. ຕົວຢ່າງ, ຜ່ານ
ຈຳນວນ 1 ແລະ 2, ໃຊ້:
funcalc -a "1 2" ...
arguments ຖືກເກັບໄວ້ໃນ array ພາຍໃນແລະຖືກເຂົ້າເຖິງເປັນ strings ຜ່ານ ARGV(n)
ມະຫາພາກ. ສໍາລັບຕົວຢ່າງ, ພິຈາລະນາການສະແດງອອກດັ່ງຕໍ່ໄປນີ້:
ທ້ອງຖິ່ນ
int pmin, pmax;
ໃນຕອນທ້າຍ
ກ່ອນທີ່ຈະ
pmin=atoi(ARGV(0));
pmax=atoi(ARGV(1));
ໃນຕອນທ້າຍ
ຖ້າ((cur->pha>= pmin) && (cur->pha <= pmax))
fprintf(stderr, "%d %d %d\n", cur->x, cur->y, cur->pha);
ການສະແດງອອກນີ້ຈະພິມອອກຄ່າ x, y, ແລະ pha ສໍາລັບແຖວທັງໝົດທີ່ຄ່າ pha ແມ່ນ
ລະຫວ່າງສອງຄ່າການປ້ອນຂໍ້ມູນຂອງຜູ້ໃຊ້:
funcalc -a '1 12' -f foo snr.ev'[cir 512 512 .1]'
+512 512 6
+512 512 8
+512 512 5
+512 512 5
+512 512 8
funcalc -a '5 6' -f foo snr.ev'[cir 512 512 .1]'
+512 512 6
+512 512 5
+512 512 5
ໃຫ້ສັງເກດວ່າມັນເປັນຄວາມຮັບຜິດຊອບຂອງຜູ້ໃຊ້ເພື່ອຮັບປະກັນວ່າຈໍານວນການໂຕ້ຖຽງທີ່ຖືກຕ້ອງ
ແມ່ນຜ່ານ. Macro ARGV(n) ສົ່ງຄືນຄ່າ NULL ຖ້າອາກິວເມັນທີ່ຮ້ອງຂໍນັ້ນຢູ່ນອກຂອບເຂດຈໍາກັດ.
ຂອງຈໍານວນຕົວຈິງຂອງ args, ໂດຍປົກກະຕິຈະສົ່ງຜົນໃຫ້ SEGV ຖ້າຖືກປະມວນຜົນ blindly. ເພື່ອກວດກາເບິ່ງ
argument count, ໃຊ້ macro ARGC:
ທ້ອງຖິ່ນ
long int seed=1;
double limit=0.8;
ໃນຕອນທ້າຍ
ກ່ອນທີ່ຈະ
if( ARGC >= 1 ) seed = atol(ARGV(0));
if( ARGC >= 2 ) limit = atof(ARGV(1));
srand48(ແກ່ນ);
ໃນຕອນທ້າຍ
ຖ້າ (drand48() > limit ) ສືບຕໍ່;
ມະຫາພາກ WRITE_ROW ຂະຫຍາຍໄປຫາ FunTableRowPut() ໂທທີ່ຂຽນແຖວປະຈຸບັນ. ມັນ
ສາມາດໃຊ້ເພື່ອຂຽນແຖວໄດ້ຫຼາຍກວ່າໜຶ່ງຄັ້ງ. ນອກຈາກນັ້ນ, macro NROW ຂະຫຍາຍໄປສູ່
ໝາຍເລກແຖວກຳລັງປະມວນຜົນຢູ່. ການນໍາໃຊ້ຂອງສອງ macro ນີ້ແມ່ນສະແດງໃຫ້ເຫັນຢູ່ໃນຕໍ່ໄປນີ້
ຍົກຕົວຢ່າງ:
if( cur->pha:I == cur->pi:I ) ສືບຕໍ່;
a = cur->pha;
cur->pha = cur->pi;
cur->pi = a;
cur->AVG:E = (cur->pha+cur->pi)/2.0;
cur->NR:I = NROW;
ຖ້າ( NROW < 10 ) WRITE_ROW;
ຖ້າ -p [ໂຄງການ] ສະວິດຖືກລະບຸ, ການສະແດງອອກບໍ່ໄດ້ຖືກປະຕິບັດ. ແທນທີ່ຈະ, ໄດ້
ການປະຕິບັດທີ່ຜະລິດໄດ້ຖືກບັນທຶກໄວ້ທີ່ມີຊື່ໂຄງການທີ່ກໍານົດໄວ້ສໍາລັບການນໍາໃຊ້ຕໍ່ມາ.
ຖ້າ -n ສະວິດຖືກລະບຸ, ການສະແດງອອກບໍ່ໄດ້ຖືກປະຕິບັດ. ແທນທີ່ຈະ, ລະຫັດທີ່ສ້າງຂຶ້ນ
ຖືກຂຽນໄວ້ໃນ stdout. ນີ້ແມ່ນເປັນປະໂຫຍດໂດຍສະເພາະຖ້າທ່ານຕ້ອງການສ້າງໄຟລ໌ skeleton
ແລະເພີ່ມລະຫັດຂອງທ່ານເອງ, ຫຼືຖ້າທ່ານຕ້ອງການກວດເບິ່ງຄວາມຜິດພາດການລວບລວມ. ໃຫ້ສັງເກດວ່າຄໍາເຫັນ
ໃນຕອນເລີ່ມຕົ້ນຂອງຜົນຜະລິດໃຫ້ຄໍາສັ່ງ compiler ທີ່ຈໍາເປັນເພື່ອສ້າງໂຄງການໃນນັ້ນ
ເວທີ. (ຄໍາສັ່ງສາມາດປ່ຽນຈາກເວທີໄປຫາເວທີເນື່ອງຈາກວ່າການນໍາໃຊ້
ຫ້ອງສະຫມຸດທີ່ແຕກຕ່າງກັນ, ສະຫຼັບ compiler, ແລະອື່ນໆ)
ດັ່ງທີ່ໄດ້ກ່າວມາກ່ອນ ໜ້າ ນີ້, funcalc ຈະປະກາດຕົວແປ scalar ໂດຍອັດຕະໂນມັດ (ເປັນ
double) ຖ້າຕົວແປນັ້ນຖືກໃຊ້ແຕ່ບໍ່ໄດ້ປະກາດ. ສະຖານທີ່ນີ້ຖືກປະຕິບັດ
ການນໍາໃຊ້ sed script ທີ່ມີຊື່ funcalc.sed, ເຊິ່ງປະມວນຜົນຜົນຜະລິດ compiler ກັບຄວາມຮູ້ສຶກ an
ຄວາມຜິດພາດຕົວແປທີ່ບໍ່ໄດ້ປະກາດ. script ນີ້ໄດ້ຖືກ seeded ດ້ວຍຄວາມຜິດພາດທີ່ເຫມາະສົມ
ຂໍ້ມູນສໍາລັບ gcc, ແລະສໍາລັບ cc ໃນແພລະຕະຟອມ Solaris, DecAlpha, ແລະ SGI. ຖ້າເຈົ້າພົບເຫັນນັ້ນ
ການປະກາດອັດຕະໂນມັດຂອງ scalar ບໍ່ເຮັດວຽກຢູ່ໃນເວທີຂອງທ່ານ, ໃຫ້ກວດເບິ່ງ script sed ນີ້;
ມັນອາດຈະຈໍາເປັນຕ້ອງເພີ່ມຫຼືແກ້ໄຂບາງຂໍ້ຄວາມຜິດພາດມັນຮູ້ສຶກ.
ເພື່ອຮັກສາການວິເຄາະ lexical ຂອງ funcalc ການສະແດງອອກ (ສົມເຫດສົມຜົນ) ງ່າຍດາຍ, ພວກເຮົາເລືອກ
ເພື່ອຍອມຮັບຂໍ້ຈໍາກັດບາງຢ່າງກ່ຽວກັບວິທີທີ່ C ຄໍາຄິດເຫັນ, ຍະຫວ່າງ, ແລະແຖວໃຫມ່ຖືກວາງໄວ້ຢ່າງຖືກຕ້ອງ
ໃນໂຄງການທີ່ສ້າງຂຶ້ນ. ໂດຍສະເພາະ, ຄໍາເຫັນທີ່ກ່ຽວຂ້ອງກັບຕົວແປທ້ອງຖິ່ນໄດ້ປະກາດ
ໃນຕອນຕົ້ນຂອງການສະແດງອອກ (ie, ບໍ່ແມ່ນຢູ່ໃນ a ທ້ອງຖິ່ນ ... ສິ້ນສຸດ block) ປົກກະຕິແລ້ວຈະສິ້ນສຸດລົງ
ໃນວົງພາຍໃນ, ບໍ່ແມ່ນການປະກາດທ້ອງຖິ່ນ:
/* ຄໍາຄິດເຫັນນີ້ຈະສິ້ນສຸດໃນບ່ອນທີ່ບໍ່ຖືກຕ້ອງ (ເຊັ່ນ: ວົງໃນ) */
double a; /* ຢູ່ໃນສະຖານທີ່ຜິດພາດ */
/* ນີ້ຈະຢູ່ໃນສະຖານທີ່ທີ່ເຫມາະສົມ (ວົງໃນ) */
ຖ້າ ( cur->x:D == cur->y:D ) ສືບຕໍ່; /* ຢູ່ບ່ອນທີ່ຖືກຕ້ອງ */
a = cur->x;
cur->x = cur->y;
cur->y = ເປັນ;
cur->avg:E = (cur->x+cur->y)/2.0;
ເຊັ່ນດຽວກັນ, ບາງຄັ້ງຊ່ອງຫວ່າງ ແລະແຖວໃໝ່ກໍຖືກລະເວັ້ນ ຫຼືເພີ່ມໃນແບບທີ່ເບິ່ງຄືວ່າບໍ່ມັກ.
ລັກສະນະ. ແນ່ນອນວ່າ, ບໍ່ມີຄວາມຜິດພາດ stylistic ເຫຼົ່ານີ້ມີຜົນກະທົບຄວາມຖືກຕ້ອງຂອງ
ລະຫັດທີ່ສ້າງຂຶ້ນ.
ເນື່ອງຈາກວ່າ funcalc ຕ້ອງວິເຄາະການສະແດງອອກຂອງຜູ້ໃຊ້ໂດຍໃຊ້ໄຟລ໌ຂໍ້ມູນທີ່ຜ່ານ
ແຖວຄໍາສັ່ງ, ໄຟລ໌ປ້ອນຂໍ້ມູນຕ້ອງຖືກເປີດ ແລະອ່ານສອງເທື່ອ: XNUMX ຄັ້ງໃນລະຫວ່າງໂຄງການ
ການຜະລິດແລະຄັ້ງດຽວໃນລະຫວ່າງການປະຕິບັດ. ດັ່ງນັ້ນ, ມັນເປັນໄປບໍ່ໄດ້ທີ່ຈະໃຊ້ stdin ສໍາລັບ
ໄຟລ໌ປ້ອນ: funcalc ບໍ່ສາມາດໃຊ້ເປັນຕົວກອງໄດ້. ພວກເຮົາຈະພິຈາລະນາເອົາຂໍ້ຈໍາກັດນີ້ອອກ
ໃນເວລາຕໍ່ມາ.
ຄຽງຄູ່ກັບຄໍາເຫັນ C, funcalc ການສະແດງອອກສາມາດມີຄໍາເຫັນພາຍໃນແຖວດຽວທີ່ເປັນ
ບໍ່ໄດ້ສົ່ງຕໍ່ກັບໂຄງການ C ທີ່ຜະລິດໄດ້. ຄວາມຄິດເຫັນພາຍໃນເຫຼົ່ານີ້ເລີ່ມຕົ້ນດ້ວຍ #
ຕົວອັກສອນແລະສືບຕໍ່ເຖິງແຖວໃຫມ່:
double a; # ອັນນີ້ບໍ່ໄດ້ຖືກສົ່ງໄປຫາໄຟລ໌ C ທີ່ສ້າງຂຶ້ນ
# ນີ້ບໍ່ແມ່ນ
a = cur->x;
cur->x = cur->y;
cur->y = ເປັນ;
/* ຄໍາຄິດເຫັນນີ້ຖືກສົ່ງໄປທີ່ໄຟລ໌ C */
cur->avg:E = (cur->x+cur->y)/2.0;
ດັ່ງທີ່ໄດ້ກ່າວມາກ່ອນຫນ້ານີ້, ຖັນການປ້ອນຂໍ້ມູນຕາມປົກກະຕິແມ່ນຖືກກໍານົດໂດຍການຖືກນໍາໃຊ້ພາຍໃນ
loop ເຫດການພາຍໃນ. ມີກໍລະນີທີ່ຫາຍາກທີ່ທ່ານອາດຈະຕ້ອງການອ່ານຄໍລໍາແລະ
ປະມວນຜົນມັນຢູ່ນອກ loop ຕົ້ນຕໍ. ຕົວຢ່າງ, qsort ອາດຈະໃຊ້ຖັນໃນການຈັດລຽງຂອງມັນ
ປົກກະຕິການປຽບທຽບທີ່ບໍ່ໄດ້ຖືກປະມວນຜົນພາຍໃນ loop ພາຍໃນ (ແລະດັ່ງນັ້ນບໍ່ແມ່ນ
ລະບຸ implicitly ເປັນຖັນທີ່ຈະອ່ານ). ເພື່ອຮັບປະກັນວ່າຄໍລໍາດັ່ງກ່າວຖືກອ່ານໂດຍ
ເຫດການ loop, ໃຊ້ ຢ່າງຊັດເຈນ ຄໍາສໍາຄັນ. ການໂຕ້ຖຽງກັບຄໍາສໍາຄັນນີ້ກໍານົດຄໍລໍາທີ່
ຄວນອ່ານເຂົ້າໃນໂຄງສ້າງບັນທຶກການປ້ອນຂໍ້ມູນເຖິງແມ່ນວ່າພວກເຂົາບໍ່ໄດ້ກ່າວເຖິງໃນ
ວົງໃນ. ຍົກຕົວຢ່າງ:
pi pha ຈະແຈ້ງ
ຈະຮັບປະກັນວ່າຖັນ pi ແລະ pha ໄດ້ຖືກອ່ານສໍາລັບແຕ່ລະແຖວ, ເຖິງແມ່ນວ່າພວກມັນບໍ່ແມ່ນ
ປະມວນຜົນໃນ loop ເຫດການພາຍໃນ. ໄດ້ ຢ່າງຊັດເຈນ ຖະແຫຼງການສາມາດຖືກວາງໄວ້ທຸກບ່ອນ.
ສຸດທ້າຍ, ໃຫ້ສັງເກດວ່າ funcalc ໃນປັດຈຸບັນເຮັດວຽກກ່ຽວກັບການສະແດງອອກທີ່ກ່ຽວຂ້ອງກັບຕາຕະລາງຄູ່ FITS ແລະ
ໄຟລ໌ເຫດການດິບ. ພວກເຮົາຈະພິຈາລະນາເພີ່ມການສະຫນັບສະຫນູນສໍາລັບການສະແດງຮູບພາບໃນຈຸດຕໍ່ມາ,
ຖ້າຫາກວ່າມີຄວາມຕ້ອງການສໍາລັບການສະຫນັບສະຫນູນດັ່ງກ່າວຈາກຊຸມຊົນ.
ໃຊ້ funcalc ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net
