funcalc - מקוון בענן

תָכְנִית:

שֵׁם

funcalc - מחשבון Funtools (לטבלאות בינאריות)

תַקצִיר

funcalc [-n] [-a argstr] [-e expr] [-f file] [-l link] [-p prog] [oname [עמודות]]

אפשרויות

-a argstr # ארגומנטים של משתמש להעביר לתוכנית הקומפילציה
-e expr # ביטוי funcalc
-f file # קובץ המכיל ביטוי funcalc
-l libs # libs כדי להוסיף לפקודת הקישור
-n # פלט קוד שנוצר במקום קומפילציה וביצוע
-p prog # ליצור תוכנית בשם, ללא ביצוע
-u # מת אם משתנה כלשהו אינו מוצהר (אל תצהיר אוטומטית)

תיאור

funcalc היא תוכנת מחשבון המאפשרת לבנות ביטויים שרירותיים,
הידור, ומבוצע על עמודות בטבלת Funtools (טבלה בינארית FITS או אירוע גולמי
קוֹבֶץ). זה עובד על ידי שילוב ביטויים שסופקו על ידי המשתמש בתוכנית תבנית C, אם כן
קומפילציה והפעלה של התוכנית. funcalc ביטויים הם הצהרות C, אם כי חלקם
הפשטות חשובות (כגון הכרזה אוטומטית של משתנים) נתמכות.

funcalc ניתן לציין ביטויים בשלוש דרכים: בשורת הפקודה באמצעות ה- -e
[ביטוי] switch, בקובץ באמצעות ה- -f [קוֹבֶץ] מתג, או מ-stdin (אם אף אחד מהם -e
ולא -f מצוין). כמובן קובץ המכיל funcalc ניתן לקרוא מהם ביטויים
סטדין.

כל קריאה של funcalc דורש שקובץ טבלת Funtools יצוין כ-
ארגומנט שורת הפקודה הראשון. קובץ הטבלה Funtools הפלט הוא האופציונלי השני
טַעֲנָה. זה נחוץ רק אם נוצר קובץ פלט FITS (כלומר, במקרים שבהם
מה היא funcalc expression מדפיס רק ערכים, אין צורך בקובץ פלט). אם קלט ופלט
שניהם מצוינים, ארגומנט אופציונלי שלישי יכול לציין את רשימת העמודות
להפעיל (באמצעות FunColumnActivate()). ציין זאת funcalc קובע אם כן או לא
ליצור קוד לכתיבת קובץ פלט בהתבסס על נוכחות או היעדר פלט
ארגומנט קובץ.

A funcalc expression מופעל בכל שורה בטבלה ומורכב מ-C אחד או יותר
הצהרות הפועלות על העמודות של אותה שורה (אולי באמצעות משתנים זמניים).
בתוך ביטוי, מתייחסים לעמודה של נוֹכְחִי שורה באמצעות מבנה C
תחביר לשחרר-[colname]>, למשל cur->x, cur->pha וכו'. ניתן להגדיר משתנים סקלרים מקומיים
באמצעות הצהרות C ממש בתחילת הביטוי, או שניתן להגדיר אותן
אוטומטית על ידי funcalc (להיות מסוג כפול). כך, למשל, החלפה של עמודות 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 otest.ev

בקובץ המתקבל יוחלפו ערכים של העמודות x ו-y.

כברירת מחדל, סוג הנתונים של המשתנה עבור עמודה זהה לסוג הנתונים של
העמודה כפי שמאוחסנת בקובץ. ניתן לשנות זאת על ידי הוספת ":[dtype]" לראשון
התייחסות לאותה עמודה. בדוגמה למעלה, כדי לאלץ את x ו-y להיות פלט כפולים,
ציין את הסוג 'D' במפורש:

temp = cur->x:D;
cur->x = cur->y:D;
cur->y = temp;

מפרטי סוגי הנתונים פועלים לפי תחביר טבלת FITS הסטנדרטי להגדרת עמודות באמצעות TFORM:

· ת: תווי ASCII

· B: char 8-bit ללא סימן

· אני: חתום 16-bit int

· U: 16-bit int ללא חתימה (לא FITS סטנדרטי)

· J: חתום 32-bit int

· V: 32-bit int ללא חתימה (לא FITS סטנדרטי)

· E: 32-bit float

· D: 64-bit float

· X: ביטים (מטופלים כמערך של תווים)

שימו לב שרק ההפניה הראשונה לעמודה צריכה להכיל את סוג הנתונים המפורש
מפרט.

כמובן שחשוב לטפל בצורה נכונה בסוג הנתונים של העמודות. אחד מ
הסיבה השכיחה ביותר לשגיאה ב funcalc תכנות הוא שימוש מרומז בנתונים שגויים
הקלד עבור עמודה בביטוי. לדוגמה, החישוב:

dx = (cur->x - cur->y)/(cur->x + cur->y);

בדרך כלל צריך לבצע באמצעות אריתמטיקה של נקודה צפה. במקרים בהם ה-x ו-y
עמודות הן מספרים שלמים, ניתן לעשות זאת על ידי קריאת העמודות כפולות באמצעות מפורש
מפרט סוג:

dx = (cur->x:D - cur->y:D)/(cur->x + cur->y);

לחלופין, ניתן לעשות זאת באמצעות יציקת סוג C בביטוי:

dx = ((double)cur->x - (double)cur->y)/((double)cur->x + (double)cur->y);

בנוסף לגישה לעמודות בשורה הנוכחית, ניתן להתייחס גם ל-
קודם שורה באמצעות הקודם-[colname]>, ול- הבא שורה באמצעות הַבָּא-[שם שם]>. ציין זאת
if הקודם-[colname]> מצוין ב- funcalc ביטוי, השורה הראשונה ממש לא
מעובד. אם הַבָּא-[colname]> מצוין ב- funcalc ביטוי, השורה האחרונה
אינו מעובד. בדרך זו, קודם ו הבא מובטח תמיד להצביע על שורות חוקיות.
לדוגמה, כדי להדפיס את הערכים של העמודה x הנוכחית ועמודת ה-y הקודמת,
השתמש בפונקציה C fprintf ב-a funcalc ביטוי:

fprintf(stdout, "%d %d\n", cur->x, prev->y);

ניתן לציין עמודות חדשות באמצעות אותו לשחרר-תחביר [colname]> על ידי הוספת העמודה
סוג (ומפרטי tlmin/tlmax/binsiz אופציונליים), מופרדים באמצעות נקודתיים. לדוגמה,
cur->avg:D יגדיר עמודה חדשה מסוג double. מפרטי סוגים זהים לאלה
משמש לעיל לציון סוגי נתונים חדשים עבור עמודות קיימות.

לדוגמה, ליצור ולהוציא עמודה חדשה שהיא הערך הממוצע של ה-x ו-y
עמודות, ניתן להגדיר עמודת "ממוצע" חדשה:

cur->avg:D = (cur->x + cur->y)/2.0

שים לב שה-';' האחרון אינו נדרש עבור ביטויים בשורה אחת.

כמו במפרט סוג הנתונים של FITS TFORM, ניתן להקדים את מפרט סוג הנתונים של העמודה
לפי ספירה מספרית כדי להגדיר מערך, למשל, "10I" פירושו וקטור של 10 אינטס קצר, "2E"
פירושו שני מצופים דיוק בודדים וכו'. עמודה חדשה צריכה להיות מוגדרת רק פעם אחת ב
funcalc expression, שלאחריו ניתן להשתמש בו מבלי לציין מחדש את הסוג. זֶה
כולל התייחסות לרכיבים של מערך עמודות:

cur->avg[0]:2D = (cur->x + cur->y)/2.0;
cur->avg[1] = (cur->x - cur->y)/2.0;

סוג הנתונים 'X' (סיביות) מטופל כמערך char של ממד (numeric_count/8), כלומר,
16X מעובד כמערך char של 2 בתים. לכל רכיב מערך של 8 סיביות יש גישה בנפרד:

cur->stat[0]:16X = 1;
cur->stat[1] = 2;

כאן נוצרת עמודה של 16 סיביות כאשר ה-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;
if( 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(). אם נעשה שימוש במשתנה לא ידוע
בביטוי, וכתוצאה מכך שגיאת קומפילציה, ניסוי בניית התוכנית חוזר לאחר מכן
הגדרת המשתנה הלא ידוע להיות מסוג double.

בדרך כלל, funcalc קוד ביטוי נוסף ל funcalc לולאת עיבוד שורה. זה אפשרי
כדי להוסיף קוד לחלקים אחרים של התוכנית על ידי הצבת קוד זה בתוך הנחיות מיוחדות
של הטופס:

[שם ההנחיה]
... הקוד מגיע לכאן ...
סוף

ההנחיות הן:

· גלוֹבָּלִי הוסף קוד והצהרות במרחב הגלובלי, לפני השגרה העיקרית.

· מקומי הוסף הצהרות (וקוד) רק אחרי ההצהרות המקומיות ב-main

· לפני הוסף קוד ממש לפני הכניסה ללולאת עיבוד השורה הראשית

· לאחר הוסף קוד מיד לאחר היציאה מלולאת עיבוד השורה הראשית

לפיכך, הדברים הבאים funcalc expression יכריז על משתנים גלובליים ויעשה תת שגרה
שיחות ממש לפני ומיד אחרי לולאת העיבוד הראשית:

גלוֹבָּלִי
כפול v1, v2;
double init(void);
גימור כפול (כפול v);
סוף
לפני
v1 = init();
סוף
... עיבוד שורות, עם חישובים באמצעות v1 ...
לאחר
v2 = finish(v1);
if( v2 < 0.0 ){
fprintf(stderr, "העיבוד נכשל %g -> %g\n", v1, v2);
יציאה(1);
}
סוף

שגרות כגון init () ו סיים() לעיל מועברים לתוכנית שנוצרה לצורך קישור
באמצעות -l [קישור הנחיות ...] החלף. המחרוזת שצוינה על ידי מתג זה תהיה
נוסף לשורת הקישור המשמשת לבניית התוכנית (לפני ספריית funtools). ל
לדוגמה, בהנחה שכך init () ו סיים() נמצאים בספרייה libmysubs.a ב-
ספריית /opt/special/lib, השתמש ב:

funcalc -l "-L/opt/special/lib -lmysubs" ...

ניתן להעביר ארגומנטים של משתמש לתוכנית funcalc הידור באמצעות ארגומנט מחרוזת ל-
מתג "-a". המחרוזת צריכה להכיל את כל הארגומנטים של המשתמש. למשל לעבור
המספרים השלמים 1 ו-2, השתמשו ב:

funcalc -a "1 2" ...

הארגומנטים מאוחסנים במערך פנימי וניגשים אליהם כמחרוזות דרך ה-ARGV(n)
מאקרו. לדוגמה, שקול את הביטוי הבא:

מקומי
int pmin, pmax;
סוף

לפני
pmin=atoi(ARGV(0));
pmax=atoi(ARGV(1));
סוף

if( (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

שימו לב שבאחריות המשתמש לוודא שהמספר הנכון של ארגומנטים
עוברים. המאקרו ARGV(n) מחזיר NULL אם ארגומנט מבוקש נמצא מחוץ לגבולות
של המספר האמיתי של args, בדרך כלל מוביל ל-SEGV אם מעובד באופן עיוור. לבדוק
ספירת הארגומנטים, השתמש במאקרו ARGC:

מקומי
long int seed=1;
גבול כפול=0.8;
סוף

לפני
if(ARGC >= 1) seed = atol(ARGV(0));
if( ARGC >= 2 ) limit = atof(ARGV(1));
srand48(זרע);
סוף

if (drand48() > limit ) להמשיך;

המאקרו WRITE_ROW מתרחב ל- FunTableRowPut() שיחה שכותבת את השורה הנוכחית. זה
ניתן להשתמש כדי לכתוב את השורה יותר מפעם אחת. בנוסף, המאקרו NROW מתרחב ל-
מספר שורה בעיבוד. השימוש בשתי פקודות המאקרו הללו מוצג בהמשך
דוּגמָה:

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;
if( NROW < 10 ) WRITE_ROW;

אם -p [פרוג] מתג צוין, הביטוי אינו מבוצע. במקום זאת, ה
קובץ ההפעלה שנוצר נשמר בשם התוכנית שצוין לשימוש מאוחר יותר.

אם -n מתג צוין, הביטוי אינו מבוצע. במקום זאת, הקוד שנוצר
נכתב ל-stdout. זה שימושי במיוחד אם אתה רוצה ליצור קובץ שלד
והוסף קוד משלך, או אם אתה צריך לבדוק שגיאות קומפילציה. שימו לב שההערה
בתחילת הפלט נותן את פקודת המהדר הדרושה לבניית התוכנית על זה
פּלַטפוֹרמָה. (הפקודה יכולה להשתנות מפלטפורמה לפלטפורמה בגלל השימוש ב
ספריות שונות, מתגי מהדר וכו')

כאמור, funcalc יכריז על משתנה סקלרי באופן אוטומטי (כמו א
כפול) אם נעשה שימוש במשתנה זה אך לא הוכרז. מתקן זה מיושם
באמצעות סקריפט sed בשם funcalc.sed, המעבד את פלט המהדר כדי לחוש an
שגיאת משתנה לא מוכרזת. סקריפט זה הוזן עם השגיאה המתאימה
מידע עבור gcc, ועבור cc בפלטפורמות Solaris, DecAlpha ו-SGI. אם תמצא את זה
ההכרזה האוטומטית של סקלרים לא עובדת בפלטפורמה שלך, בדוק את הסקריפט הזה;
ייתכן שיהיה צורך להוסיף או לערוך חלק מהודעות השגיאה שהוא חש.

על מנת לשמור על הניתוח המילוני של funcalc ביטויים (באופן סביר) פשוטים, בחרנו
לקבל כמה מגבלות לגבי מיקום המדויק של הערות C, רווחים ושורות חדשות
בתוכנית שנוצרה. בפרט, הוכרזו הערות הקשורות למשתנים מקומיים
בתחילת ביטוי (כלומר, לא ב-a מקומי...סוף בלוק) יסתיים בדרך כלל
בלולאה הפנימית, לא עם ההצהרות המקומיות:

/* ההערה הזו תגיע למקום הלא נכון (כלומר, לולאה פנימית) */
כפול א; /* גם במקום לא נכון */
/* זה יהיה במקום הנכון (לולאה פנימית) */
if( cur->x:D == cur->y:D ) להמשיך; /* גם במקום הנכון */
a = cur->x;
cur->x = cur->y;
cur->y = a;
cur->avg:E = (cur->x+cur->y)/2.0;

באופן דומה, רווחים וקווים חדשים לפעמים מושמטים או מוסיפים באופן שרירותי לכאורה
דֶרֶך. כמובן, אף אחד מהפגמים הסגנוניים הללו לא משפיע על נכונות ה
קוד שנוצר.

כי funcalc חייב לנתח את ביטוי המשתמש באמצעות קבצי הנתונים שהועברו על
שורת הפקודה, יש לפתוח את קבצי הקלט ולקרוא פעמיים: פעם אחת במהלך התוכנית
דור ופעם אחת במהלך הביצוע. כתוצאה מכך, לא ניתן להשתמש ב-stdin עבור ה
קובץ קלט: funcalc לא יכול לשמש כמסנן. נשקול להסיר מגבלה זו
במועד מאוחר יותר.

יחד עם הערות C, funcalc לביטויים יכולים להיות הערות פנימיות בשורה אחת שכן
לא הועבר לתוכנית C שנוצרה. הערות פנימיות אלו מתחילות ב- #
תו והמשך עד לשורה החדשה:

כפול א; # זה לא מועבר לקובץ C שנוצר
# וגם זה לא
a = cur->x;
cur->x = cur->y;
cur->y = a;
/* הערה זו מועברת לקובץ C */
cur->avg:E = (cur->x+cur->y)/2.0;

כפי שהוזכר קודם לכן, עמודות קלט מזוהות בדרך כלל על ידי השימוש בהן
לולאת האירועים הפנימית. ישנם מקרים נדירים שבהם אולי תרצה לקרוא טור ו
לעבד אותו מחוץ ללולאה הראשית. לדוגמה, qsort עשוי להשתמש בעמודה במיון שלה
שגרת השוואה שאינה מעובדת בתוך הלולאה הפנימית (ולכן לא
צוין באופן מרומז כעמודה לקריאה). כדי להבטיח שטור כזה ייקרא על ידי ה
לולאת אירוע, השתמש ב- מפורש מילת מפתח. הארגומנטים למילת מפתח זו מציינים עמודות ש
יש לקרוא לתוך מבנה רשומת הקלט למרות שהם לא מוזכרים ב-
לולאה פנימית. לדוגמה:

פי פאה מפורש

יבטיח שעמודות ה-pi וה-pha ייקראו עבור כל שורה, גם אם לא
מעובד בלולאת האירועים הפנימית. ה מפורש ניתן למקם את ההצהרה בכל מקום.

לבסוף, שים לב לכך funcalc עובד כרגע על ביטויים הכוללים FITS טבלאות בינאריות ו
קבצי אירועים גולמיים. נשקול להוסיף תמיכה בביטויי תמונה בשלב מאוחר יותר,
אם יש דרישה לתמיכה כזו מהקהילה.

השתמש ב-funcalc באינטרנט באמצעות שירותי onworks.net