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

ໂຄງການ:

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