ממיר בסיסי ספירה

מה הכלי הזה עושה

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

מה שמבדיל אותו ממחשבון בית־ספר הוא בורר הרוחב ורשת הביטים. בחרו ‎8, 16, 32 או 64 ביט ומספרים שליליים יקבלו את הייצוג האמיתי שלהם במכונה במקום סימן מינוס, וכל ביט הופך למשהו שאפשר ללחוץ עליו.

מה זה בעצם בסיס

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

1011           # המספר, בבסיס 2
1 x 8 = 8      # ביט 3
0 x 4 = 0      # ביט 2
1 x 2 = 2      # ביט 1
1 x 1 = 1      # ביט 0
8+0+2+1 = 11   # הסכום, בעשרוני

בסיסים מעל עשר זקוקים ליותר מעשרה סמלי ספרות, ולכן הם שואלים אותיות: הקסדצימלי רץ ‎0‑9 ואז a‑f, כאשר a הוא 10 ו־f הוא 15. זה נמשך עד בסיס 36, שמשתמש בכל ספרה ובכל אות — הבסיס הגדול ביותר שאפשר לכתוב עם האלפבית הפשוט, וזו הסיבה שהכלי הזה עוצר שם.

למה הקסדצימלי, ולא משהו אחר

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

d    e    a    d
1101 1110 1010 1101   # כל ספרת הקס היא ניבל משלה

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

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

מספרים שליליים ומשלים ל־2

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

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

0000 0101   # 5
1111 1010   # כל ביט הפוך
1111 1011   # ועוד אחד: ‎-5‎ כבייט, או fb בהקס

הרחיבו את האוגר ואותו מספר יקבל תבנית אחרת: ‎-5‎ הוא fb ב־8 ביט, fffb ב־16 ו־fffffffb ב־32. הערך לא השתנה; מספר הביטים שנושאים אותו כן. החלפת רוחב בכלי הזה מראה בדיוק את זה.

למה 0xFF הוא גם 255 וגם ‎-1‎

הביטים ff אינם אומרים אם הם מסומנים. בייט שמחזיק ‎1111 1111 נקרא כ־255 אם הקוד שטוען אותו הצהיר על טיפוס לא מסומן, וכ־‎-1‎ אם הצהיר על מסומן. שום דבר בבייט עצמו אינו מבחין בין השניים — הטיפוס הוא טענה שהתוכנית מעלה על ביטים שאינם נושאים מידע כזה.

זה המקור למשפחה שלמה של באגים אמיתיים: checksum שיוצא שלילי, בייט שנקרא מקובץ ומושווה כקטן מאפס, char ב־C שמתנהג אחרת ב־ARM ובx86 כי הסימון שלו מוגדר על ידי המימוש. בכל פעם שהקריאה המסומנת והלא מסומנת נבדלות, הכלי הזה מציג את שתיהן, כי אי־ההתאמה היא בדרך כלל הדבר שחיפשתם.

רשת הביטים

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

• איזה ביט דלוק בערך הדגלים הזה — לחצו עליהם וקראו את המיקומים.
• מהי המסכה לביטים 4 ו־7 — הדליקו את השניים וקראו את ההקס.
• מה עושה הדלקת הביט העליון לערך מסומן — היא הופכת אותו לשלילי, באופן גלוי.
• האם הערך הזה הוא חזקה של שתיים — לחזקה של שתיים יש בדיוק ביט אחד דלוק.

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

מספרים גדולים נשארים מדויקים

מספרים ב־JavaScript הם doubles, שמחזיקים שלמים במדויק רק עד ‎2^53 — בערך 9 קוודריליון. ערך של 64 ביט יכול לחרוג מזה, וממיר שבנוי על מספרים רגילים יעגל אותו בשקט, וייתן מחרוזת הקס שנראית סבירה ושגויה בספרות האחרונות שלה.

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

מבינארי לעשרוני, ומעשרוני לבינארי

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

• מבינארי לעשרוני, בהכפלה: מתחילים מאפס בביט השמאלי ביותר, ואז לכל ביט מכפילים פי שתיים את מה שיש ומוסיפים את הביט. עבור 1011 זה רץ ‎1, 2, 5, 11 — מעבר אחד, בלי ערכי מיקום לזכור, וזה בדיוק מה שהכלי הזה עושה כשהוא קורא את מה שהקלדתם.
• מבינארי לעשרוני, לפי מיקום: מחברים את ערך המיקום של כל ביט דלוק, וזו הדוגמה המפורטת למעלה. מהיר יותר כששניים או שלושה ביטים דלוקים, איטי יותר כשרובם דלוקים.
• מעשרוני לבינארי, בחילוק: מחלקים בשתיים ורושמים את השארית, שוב ושוב, עד שלא נשאר כלום — ואז קוראים את השאריות מלמטה למעלה. התשובה מגיעה כשהביט הפחות משמעותי ראשון, ולכן היא נראית הפוכה כל הזמן שכותבים אותה.
• מעשרוני לבינארי, בחיסור: מחסירים את החזקה הגדולה ביותר של שתיים שנכנסת, וחוזרים. 200 מאבד 128 ונשארים ‎72; 72 מאבד 64 ונשארים ‎8; 8 מאבד 8 ולא נשאר כלום — ולכן הביטים במיקומים ‎7, 6 ו־3 דלוקים והבייט הוא ‎1100 1000. מהיר יותר מחילוק בכל פעם שמעט ביטים דלוקים.

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

מעשרוני להקס, ומהקס לעשרוני

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

• 255 הוא ff — בייט שכל הביטים שלו דלוקים. זה הערך שכדאי לזכור בעל פה, כי שם הבייט נעצר.
• 256 הוא 100. צעד אחד מעבר לבייט מלא הספרות מתגלגלות, בדיוק כמו ש־99 מתגלגל ל־100 בעשרוני, והמספר ההקסדצימלי מקבל ספרה שהבייט אינו יכול להחזיק.
• 65535 הוא ffff ו־65536 הוא 10000: אותם שני ציוני דרך בייט אחד למעלה, ושם נעצר מונה של שש־עשרה ביט.
• 4096 הוא 1000, ולכן גדלי דפים, יישורים והיסטים בזיכרון נראים עגולים בהקס ומשוננים בעשרוני. ההקס סופר ברביעיות של ביטים, וכך גם החומרה.

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

מאוקטלי לעשרוני, והאפס המוביל שמשנה את התשובה

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

• 755 הוא 493 בעשרוני, 644 הוא 420, ו־777 הוא 511. אף אחד מהמספרים העשרוניים האלה אינו מועיל לאיש, וזו בדיוק הנקודה — הרשאות נכתבות באוקטלי כי הספרות מתיישרות עם ביטי ההרשאה, לא כי הערך סופר משהו.
• אפס מוביל הוא סמן בסיס ב־C וב־Python 2, שם 0755 הוא אוקטלי ולכן המספר ‎493. Python 3 דוחה את הכתיב הזה מכל וכל ורוצה 0o755 במקומו, מה שהעלים משפחה שלמה של באגים שקטים.
• YAML 1.1 קורא 0755 לא מצוטט כ־493 גם הוא, ולכן מצב הרשאות בקובץ תצורה חייב לבוא במירכאות או שהוא מפסיק להיות המצב שכתבתם.
• JSON מעולם לא הרשה את זה. הדקדוק שלו אוסר אפס מוביל במספר, ולכן 0755 אינו מספר שם כלל אלא שגיאת ניתוח — ההתנהגות הרועשת מבין השלוש, והיחידה שאי אפשר לקרוא לא נכון.

הכלי הזה אינו רואה באפס מוביל סמן לשום דבר. השדה שמקלידים בו קובע את הבסיס, ולכן 0755 בשדה העשרוני הוא 755 ובשדה האוקטלי הוא 493, והקידומת 0o מתקבלת בשדה האוקטלי ונדחית בכל מקום אחר. ניחוש בסיס לפי קידומת היה אומר להחזיר מספר אחר מזה שהוקלד.

מאוקטלי להקס: הצמד שאין לו קיצור

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

• כותבים כל ספרה אוקטלית כשלושת הביטים שלה, לפי הסדר: 755 הופך ל־‎111 101 101.
• מקבצים את הביטים האלה מחדש לרביעיות מהקצה הימני, ומרפדים משמאל באפסים כשהספירה אינה מתחלקת בדיוק: ‎0001 1110 1101.
• קוראים כל קבוצה של ארבעה כספרת הקס אחת: 1ed. ריפוד בקצה הלא נכון הוא הטעות הקלאסית כאן, והיא אינה נראית שגויה — היא פשוט מכפילה את התשובה בשקט.

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