aribas - מקוון בענן

תָכְנִית:

שֵׁם

aribas - מתורגמן אריתמטי רב דיוק

תַקצִיר

אריבס [אפשרויות] [קובץ ari> [arg1>arg2> ...]]

דף אדם זה נכתב עבור דביאן מכיוון שהתוכנה המקורית לא הכילה גבר
עמוד.

תיאור

אריבס הוא מתורגמן אינטראקטיבי המתאים לחשבון מספר שלם גדול ו
אריתמטיקה של נקודה צפה מרובת דיוק. יש לו תחביר דומה לפסקל או Modula-2,
אבל מכיל גם תכונות משפות תכנות אחרות כמו C, Lisp, Oberon.

נוהג

הדרך הפשוטה ביותר לשימוש אריבס הוא כמחשבון לאריתמטיקה (מספר שלם גדול). לאחר
אריבס מופעל, הוא מציג הנחיה ==> והוא מוכן לקבל קלט. כל שעליך לעשות הוא להזין את
ביטוי שברצונך לחשב, ואחריו נקודה, ולאחר מכן הקש RETURN, עבור
דוגמה

==> 123 + 456*789.

אריבס תשובות

-: 359907

הסמל -: מציג את התוצאה.
חָשׁוּב. כדי לסמן את סוף הקלט שלך, עליך תמיד להקליד נקודה '.' ואז
לחץ על RETURN.

אתה יכול להקצות את התוצאה של חישוב למשתנה, כמו ב

==> F6 := 2**64 + 1.
-: 18446_74407_37095_51617

זה מחשב את מספר הפרמה השישי (** מציין אקספוננציה) ומשייך אותו ל-
משתנה F6 (ציין זאת אריבס הוא רגיש לאותיות גדולות, כך שזה לא אותו דבר כמו f6). יותר מאוחר
אתה יכול להשתמש במשתנה הזה למשל בביטוי

==> 123**(F6 - 1) mod F6.
-: 688_66214_58712_63971

מה שמראה (לפי משפט פרמה) ש-F6 אינו מספר ראשוני.
שלוש התוצאות האחרונות מאוחסנות במשתני הפסאודו _, __, ו ___. פורום
לדוגמה אתה יכול לאחסן את התוצאה האחרונה במשתנה x על ידי הפקודה

==> x := _.
-: 688_66214_58712_63971

כפי שניתן לראות בדוגמאות לעיל, אריבס משתמש בקו התחתון _ כדי לבנות את הפלט
של מספרים שלמים גדולים (>= 2**32). גם עבור קלט של מספרים שלמים אתה יכול להשתמש בקו התחתון, ה
התנאי היחיד הוא שמיד לפני ואחרי הקו התחתון יש ספרות,
דוּגמָה:

==> z := 123_4567_890.
-: 1234567890

כאן הפלט אינו מכיל קו תחתון, מה שמראה ש-z קטן מ-2**32.

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

==> rho_factorize(F6).

עובד ..
גורם שנמצא לאחר 512 איטרציות

-: 274177

כדי למצוא את הקו-פקטור הנותר, תן את הפקודה

==> x := F6 div _.
-: 6728_04213_10721

כדי לבדוק אם גורם זה הוא ראשוני, מבחן ההסתברות של רבין rab_primetest יכול להיות
הוחל:

==> rab_primetest(x).
-: נכון

הפונקציה rho_factorize טוב למציאת גורמים קטנים (נניח עד 10 עשרוני
ספרות); למשימות פירוק מסובכות יותר, אלגוריתם חזק יותר כמו
מסננת ריבועית qs_factorize יש להשתמש

==> qs_factorize(2**128+1).

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

שליטה מבנים
אל האני ל לולאה וה בזמן לולאה אריבס יש תחביר כמו ב- Modula-2. לדוגמה, ה
רצף הפקודות הבא מחשב את הפקטוריאלי של 100.

==> x := 1;
עבור i := 2 עד 100 דו
x := x*i;
הסוף;
x.

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

מעל ל לולאה שווה ערך להלן בזמן לולאה

==> x := 1; i := 2;
בזמן שאני <= 100 כן
x := x*i;
inc(i);
הסוף;
x.

המבנה המסועף
if ... אז ... אלסיף ... אחר ... סוף
יש גם את אותו תחביר כמו ב- Modula-2.

דיוק רב צף נקודה אריתמטי
אריבס תומך בסוגים שונים של מספרי נקודה צפה המיוצגים באופן פנימי
עם מנטיסים באורך סיביות שונה:

single_float 32 ביטים
double_float 64 סיביות
long_float 128 ביטים

וכמה דיוקים גבוהים יותר עד לגבול תלוי יישום, בדרך כלל 1024 או
5120 סיביות, שניתן לקבוע על ידי הפונקציה max_floatprec(). כברירת מחדל, מתי
חישוב עם מספרים של סוג נתונים ממשי, משמשים single_floats. זה מתאים לא
דיוק של 9 עד 10 מקומות עשרוניים. דיוק של 5120 סיביות מתאים ליותר מ-1500
מקומות עשרוניים.

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

==> set_floatprec(100).
-: 128

דיוק הנקודה הצפה הוא 128 סיביות ואתה יכול לחשב

==> arctan(מ"ר(3)).
-: 1.04719_75511_96597_74615_42144_61093_16762_8

==> _/pi.
-: 0.33333_33333_33333_33333_33333_33333_33333_33

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

==> פונקציה fac(n: מספר שלם): מספר שלם;
היה
x,i: מספר שלם;
להתחיל
x := 1;
עבור i := 2 ל-n do
x := x*i;
הסוף;
החזר x;
הסוף.

אם הזנת את זה נכון, אריבס מהדהד את שם הפונקציה

-: פנים

ומעכשיו אתה יכול להשתמש fac באותו אופן כמו פונקציה מובנית, למשל

==> fac(32).
-: 2_63130_83693_36935_30167_21801_21600_00000

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

==> פונקציה sqrt_list(n: מספר שלם): מערך של אמיתי;
היה
vec: מערך[n] של אמיתי;
i: מספר שלם;
להתחיל
עבור i := 1 ל-n do
vec[i-1] := sqrt(i);
הסוף;
לחזור vec;
הסוף.

פונקציה זו מחזירה מערך של השורשים הריבועיים של המספרים השלמים מ-1 עד n, עבור
דוגמה

==> sqrt_list(10).
-: (1.00000000, 1.41421356, 1.73205081, 2.00000000,
2.23606798, 2.44948974, 2.64575131, 2.82842712, 3.00000000,
3.16227766)

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

==> load("abcd").

אם יש שגיאת תחביר בקובץ, אתה מקבל הודעת שגיאה של הטופס

שגיאה בשורה <= 23 של הקובץ שנטען
אם: סוף צפוי

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

באינטרנט לעזור
הפקודה

==> סמלים(אריבס).

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

(ARGV, _, __, ___, abs, alloc, ו, arccos, arcsin, arctan, arctan2, aribas, array, atof,
atoi, begin, binary, bit_and, bit_clear, bit_length, ...... , tolower, topupper,
תמליל, true, trunc, type, user, var, version, while, write, write_block, write_byte,
כתוב)

עבור רוב הסמלים ברשימה זו, תוכל לקבל עזרה מקוונת קצרה באמצעות הפונקציה
עֶזרָה(). למשל, הפקודה

==> עזרה(ARGV).

נותן מידע על המשתנה המובנה ARGV, ואילו

==> עזרה (בזמן).

מתאר את התחביר של ה בזמן לוּלָאָה. אם אתה צריך יותר מידע ממה שהכיל
בעזרה המקוונת, עיין בתיעוד שניתן למצוא ב /usr/share/doc/aribas.

איך ל יציאה
כדי לסיים א אריבס הפעלה, הקלד יציאה ב אריבס הפקודה

==> יציאה

ולאחר מכן הקש על מקש RETURN (ENTER).

אם אתה לא רוצה לעזוב אריבס, אבל רוצה לצאת מלולאה אינסופית או א
חישוב שנמשך זמן רב מדי, הקלד CONTROL-C (אם אתה פועל אריבס מבפנים
Emacs, עליך ללחוץ פעמיים על CONTROL-C). זה יעצור (ברוב המקרים) את הזרם
חישוב וחזרה ל אריבס הפקודה.

כאשר אינך משתמש בממשק Emacs אלא בגרסת שורת הפקודה של אריבס, אתה
לפעמים מגיעים למצב הבא: שורה קודמת כלשהי מכילה שגיאת הקלדה,
אבל אתה לא יכול לחזור לשורה הזו כדי לתקן אותה. במקרה זה עליך פשוט להקליד א
עצירה מוחלטת '.', ואחריו RETURN. תקבל הודעת שגיאה שתוכל בבטחה
התעלם, והנחיה חדשה ==> מופיע, ומאפשר לך לנסות שוב.

פקודה קו טיעונים

אריבס [אפשרויות] [קובץ ari> [arg1>arg2> ...]]

אפשרויות
האפשרויות הבאות זמינות:

-q (מצב שקט) מדכא את כל ההודעות למסך (גרסה מס', הודעת זכויות יוצרים,
וכו') מתי אריבס התחיל

-v (מצב מילולי, ברירת מחדל) אינו מדכא הודעות למסך כאשר אריבס is
התחיל.

-c
אריבס עושה שבירת שורות משלו בעת כתיבה למסך. בדרך כלל זה מניח
שהמסך (או החלון שבו אריבס פועל) יש 80 עמודות. עם ה-c
אפשרות אתה יכול להגדיר מספר אחר, שעליו להיות בין 40 ל-160 (בעשרוני
יִצוּג). למשל, אם אתה רץ אריבס בחלון Xterm עם 72
עמודות, השתמש באפשרות -c72 (או -c 72, הרווח בין -c למספר הוא
אופציונאלי).

-m
כאן הוא מספר (בייצוג עשרוני) בין 500 ל-32000. זה
מספר מציין כמה קילובייט של זיכרון RAM אריבס צריך להשתמש עבור אריבס ערימה.
ערך ברירת המחדל תלוי באפשרויות המשמשות כאשר אריבס חובר. בדרך כלל,
תחת UNIX או LINUX זה 6 מגה-בייט, המקביל ל-m6000

-h of לעזור קובץ>
העזרה המקוונת של אריבס תלוי בקובץ aribas.hlp שבו צריך להיות ממוקם
הטווח של משתנה הסביבה PATH. אם זה לא המקרה אתה יכול לציין
הנתיב המדויק של קובץ העזרה עם האפשרות -h. אם למשל הקובץ
aribas.hlp נמצא בספרייה / usr / local / lib, השתמש באפשרות -h / usr / local / lib
(אין צורך ברווח שאחרי -h). ניתן להשתמש באפשרות -h גם אם העזרה
לקובץ יש שם אחר. אם קובץ העזרה נקרא help-aribas והוא נמצא ב-
ספרייה /home/joe/ari, השתמש ב-h/home/joe/ari/help-aribas.

עם חבילת Debian המותקנת כהלכה של אריבס זה לא אמור להיות הכרחי
השתמש באפשרות זו.

-p
עם אפשרות זו אתה יכול לציין נתיב חיפוש לטעינת קבצים עם אריבס מָקוֹר
קוד. יכול להיות שם הנתיב (המוחלט) של ספרייה אחת או
מספר שמות נתיבים מופרדים בנקודתיים. נניח שהתקשרת אריבס עם
האפשרות

-p/usr/local/lib/aribas:~/ari/examples

ושספריית הבית שלך היא /home/alice/. ואז הפקודה

==> load("גורם").

יחפש בקובץ factor.ari תחילה בספרייה הנוכחית, ולאחר מכן ב-
ספרייה /usr/local/lib/aribas ולבסוף ב-/home/alice/ari/examples.

-b מצב אצווה בעת טעינת א אריבס קובץ קוד המקור משורת הפקודה, ראה
לְהַלָן.

אפשר למזג אפשרויות של אות אחת שאינן דורשות ארגומנטים, למשל

aribas -q -b

שווה

aribas -qb

עוד הפקודה קו טיעונים

הארגומנט הבא של שורת הפקודה אחרי האפשרויות מתפרש כשם של a
קובץ עם אריבס קוד מקור. אם לשם הקובץ יש את הסיומת .ari, זה
ניתן להשמיט את ההרחבה. הקובץ נטען כאילו הפקודה לִטעוֹן(" ")
ניתנה לאחר תחילת אריבס ב אריבס מיידי. אם הקובץ לא
נמצא בספרייה הנוכחית, הוא מחפש בספריות שצוינו על ידי
אפשרות -p. אם ניתנה האפשרות -b, הקובץ נטען ומבוצע.
לאחר מכן אריבס יוצא מבלי להציג את ההנחיה. אם לא ניתן לטעון את הקובץ
לגמרי בגלל טעות, אריבס יוצא מיד לאחר הודעת השגיאה.

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

הסטארט-אפ של aribas 4536 אייזנשטיין

והספרייה הנוכחית מכילה את הקובץ startup.ari, אז אריבס טוען אותו ו
הווקטור ARGV יש את הטופס

==> ARGV.
-: ("אתחול", "4536", "ייזןשטיין")

אם אתה צריך כמה ארגומנטים כמספרים ולא כמחרוזות, אתה יכול לשנות אותם על ידי
אטוי (אוֹ אטופ); בדוגמה שלנו

==> x := atoi(ARGV[1]).
-: 4536

יעשה את זה. אורך הווקטור ARGV ניתן לקבוע על ידי אורך (ARGV).

רץ ARIBAS בְּתוֹך EMACS

אתה יכול לרוץ אריבס מתוך Emacs על ידי מתן הפקודה (במיני באפר של Emacs)

Mx run-aribas

(אם אין לך מפתח META, השתמש ב-ESC x במקום Mx) לאחר מכן אריבס ייטען לתוך
חלון Emacs עם השם *aribas* ואתה יכול לערוך את הקלט שלך אריבס עם הרגיל
פקודות Emacs.

אם הקלט שלך מסתיים בנקודה '.' ואתה לוחץ על RETURN, זה נשלח אל אריבס. אם
אולם הקלט המלא שלך אינו מסתיים בנקודה, (למשל בתגובה ל-a
readnn), הקלט נשלח אל אריבס על ידי Cj (Control-j) או Cc RETURN.

אם ברצונך לחזור על קלט קודם, Mp (או ESC p) עובר אחורה דרך הקלט
היסטוריה, ו-Mn (או ESC n) עובר מחזוריות קדימה.

Control-C נשלח אל אריבס על ידי Cc Cc (לחץ על Cc פעמיים).

אפשר גם להתחיל אריבס מ-Emacs עם ארגומנטים של שורת הפקודה. לזה
מטרת הפקודה

Cu Mx run-aribas

יש לתת. ואז הנחיה

run-aribas: aribas

מופיע ב-Minibuffer של Emacs ותוכל להשלים את שורת הפקודה, למשל

run-aribas: הסטארט-אפ של aribas 4536 eisenstein

(ראה לעיל).

תְצוּרָה קובץ

אפשרויות לריצה אריבס ניתן לציין גם באמצעות קובץ תצורה עם שם
.arirc. אריבס מחפש קובץ תצורה בסדר הבא:

1) הספרייה הנוכחית
2) ספריית הבית של המשתמש

ישנה אפשרות שלישית: ניתן להגדיר משתנה סביבה ARIRC המכיל את
שם קובץ התצורה (שעשוי להיות שונה מ-.arirc), כולל המלא
נתיב.

בקובץ התצורה אתה יכול לציין את כל אפשרויות שורת הפקודה שתוארו לעיל אילו
התחל בסימן -, אולם יש להשתמש בשורה נפרדת עבור כל אפשרות בודדת. שורות
שמתעלמים מהתו # או משורות ריקות. בנוסף לאפשרויות
שתואר לעיל, קובץ התצורה עשוי להכיל אריבס קוד מקור. למטרה זו
חייבת להיות קריאת שורה

-ניט

ואז כל מה שאחרי הקו הזה יטופל כמו אריבס קוד מקור ומופעל מתי אריבס
התחיל.

קיומו של קובץ תצורה עבור אריבס אינו שולל את האפשרות לתת
ארגומנטים של שורת הפקודה. אם אפשרות (למשל אפשרות -m) צוינה הן ב-
קובץ התצורה ושורת הפקודה אך עם ערכים שונים, ולאחר מכן המפרט
בשורת הפקודה חוקי. באופן אנלוגי, אפשרות -v בשורת הפקודה עוקפת את -q
אפשרות בקובץ התצורה. אם יש קוד -init בקובץ התצורה ו-an
ארגומנט בשורת הפקודה, ואז הקוד -init מבוצע תחילה ו
לאחר מכן ה נטען והקוד שלו מופעל.

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