מספרים ב-R: Numeric, Integer ופונקציות מתמטיות

Numeric ו-Integer: שני טיפוסי המספרים של R

R מאחסן מספרים בשתי דרכים. Numeric (מאוחסן כנקודה צפה בדיוק כפול) הוא ברירת המחדל: כל מספר שמקלידים הוא double אלא אם אומרים אחרת. Integer הוא טיפוס נפרד ומדויק למספרים שלמים, שמבקשים עם הסיומת L:

x <- 3.14
n <- 42L

cat(typeof(x), typeof(n), "\n")
cat(class(x), class(n), "\n")

בפועל רק לעיתים רחוקות צריך להתעניין בזה: R ממיר ביניהם בשקט, ו-is.numeric() הוא TRUE לשניהם (ראו טיפוסי נתונים למערכת הטיפוסים המלאה). המקום היחיד שבו ההבחנה נחשפת הוא חילוק: / תמיד מחזיר double, גם בין שני מספרים שלמים:

cat(7L / 2L, "\n")
cat(typeof(7L / 2L), "\n")

מספרים שלמים מופיעים בעיקר כפלט של פונקציות ספירה (length(), seq_len(), nrow()) וכערכי אינדקס. כשצריך חילוק שלמים, ל-R יש אופרטור ייעודי, שמוסבר בהמשך.

משפחת העיגול

R נותן חמש דרכים לקצץ מספר, ולכל אחת משמעות שונה:

cat(round(3.14159, 2), "\n")
cat(floor(2.7), "\n")
cat(ceiling(2.1), "\n")
cat(trunc(-2.7), "\n")
cat(signif(123456, 2), "\n")

• round(x, digits): למספר ספרות אחרי הנקודה (ברירת מחדל 0).
• floor(x): למטה, למספר השלם הקרוב, תמיד לכיוון מינוס אינסוף.
• ceiling(x): למעלה, תמיד לכיוון פלוס אינסוף.
• trunc(x): חותך את הספרות אחרי הנקודה, תמיד לכיוון אפס. שימו לב להבדל במספרים שליליים: trunc(-2.7) הוא -2, אבל floor(-2.7) הוא -3.
• signif(x, digits): למספר ספרות משמעותיות, לא ספרות אחרי הנקודה: signif(123456, 2) הוא 120000.

והפתעה מפורסמת אחת: round() משתמש בעיגול חצי לזוגי (עיגול בנקאי) על חצאים מדויקים, לפי תקן IEEE 754:

cat(round(0.5), round(1.5), round(2.5), round(3.5), "\n")

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

פונקציות מתמטיות יומיומיות

הבסיס עובד בדיוק כמו שהייתם מנחשים:

cat(sqrt(16), "\n")
cat(abs(-7.5), "\n")
cat(2^10, "\n")
cat(round(exp(1), 6), "\n")

sqrt() הוא השורש הריבועי, abs() הערך המוחלט, ^ הוא העלאה בחזקה, ו-exp(x) הוא e בחזקת x, כך ש-exp(1) הוא המספר של אוילר, בערך 2.718282.

הפונקציה היחידה שמכשילה אנשים היא log(). ב-R, log() הוא הלוגריתם הטבעי (בבסיס e), לא בבסיס 10:

cat(log(100), "\n")
cat(log10(100), "\n")
cat(log2(8), "\n")
cat(log(8, base = 2), "\n")

השורה הראשונה מדפיסה בערך 4.60517, לא את ה-2 שקורא שחושב בבסיס 10 מצפה לו. פנו ל-log10() ול-log2() כשאתם מתכוונים לבסיסים האלה, או העבירו base = במפורש. (המוסכמה הזו סטנדרטית בכל הסטטיסטיקה, שבה הלוגריתם הטבעי הוא ברירת המחדל.)

מודולו %% וחילוק שלמים %/%

שני אופרטורים מכסים חשבון של שארית:

cat(17 %% 5, "\n")
cat(17 %/% 5, "\n")

%% הוא המודולו (השארית): 17 חלקי 5 הוא 3 ושארית 2. %/% הוא חילוק שלמים: כמה פעמים 5 שלם נכנס ב-17. יחד הם מקיימים x == (x %/% y) * y + (x %% y).

השימוש הקלאסי ב-%% הוא בדיקת התחלקות:

n <- 12
cat(n %% 2 == 0, "\n")
cat(n %% 5 == 0, "\n")

עדינות אחת עם מספרים שליליים: %% של R מקבל את הסימן של המחלק (כמו Python, בשונה מ-C):

cat(-7 %% 3, "\n")

זה 2, לא -1: R עונה על השאלה "מה מוסיפים לכפולה של 3 כדי להגיע למינוס 7?", מה ששומר את התוצאות בטווח 0..2 עבור מחלק חיובי. שימושי לגלישה של אינדקסים; מפתיע אם אתם מגיעים מ-C או מ-Java.

ערכים מיוחדים: Inf, -Inf ו-NaN

המספרים של R עוקבים אחרי IEEE 754, ולכן חלק מהפעולות מפיקות ערכים מיוחדים במקום שגיאות:

cat(1 / 0, "\n")
cat(-1 / 0, "\n")
cat(0 / 0, "\n")

1/0 הוא Inf (אינסוף), -1/0 הוא -Inf, ו-0/0, כמות שבאמת אינה מוגדרת, הוא NaN, "not a number". ההבחנה חשובה: Inf הוא תשובה ("גדול מכל דבר"), NaN הוא היעדר של תשובה. בודקים אותם עם פונקציות ייעודיות, כי == NaN אף פעם לא עובד:

cat(is.infinite(1 / 0), "\n")
cat(is.nan(0 / 0), "\n")
cat(is.na(0 / 0), "\n")

שימו לב לשורה האחרונה: NaN נחשב גם NA, ולכן is.na() תופס אותו. עוד סיבה לכך ש-is.na() היא הבדיקה הסטנדרטית ל"האם הערך הזה לא שמיש?" (עוד בערכים חסרים).

R גם קורא וכותב כתיב מדעי באופן טבעי: 2.5e3 הוא 2500, ומספרים קטנים או גדולים מאוד מודפסים בכתיב e כברירת מחדל:

cat(2.5e3, "\n")
cat(1e-4, "\n")
cat(format(1e-4, scientific = FALSE), "\n")

השתמשו ב-format(x, scientific = FALSE) (או באפשרות scipen) כשדוח צריך מספרים עשרוניים רגילים.

ההפתעה של הנקודה הצפה

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

cat(0.1 + 0.2 == 0.3, "\n")
print(0.1 + 0.2, digits = 17)

FALSE, כי 0.1 + 0.2 הוא בעצם 0.30000000000000004. לא ל-0.1 ולא ל-0.2 יש ייצוג בינארי מדויק, והשגיאות הזעירות מצטברות. ההדפסה של R כברירת מחדל מסתירה את זה כי היא מציגה 7 ספרות משמעותיות, ולכן הבעיה מרגישה בלתי נראית עד שהשוואת == נכשלת.

הכלל: לעולם אל תשוו מספרים עשרוניים מחושבים עם ==. השתמשו ב-all.equal(), שמשווה בתוך סובלנות סבירה:

cat(isTRUE(all.equal(0.1 + 0.2, 0.3)), "\n")

עטפו אותו ב-isTRUE() כי all.equal() מחזיר תיאור של ההבדל (ולא FALSE) כשהערכים שונים. לעבודה עם מספרים שלמים שבה הדיוק חשוב, מספרי integer מדויקים עד בערך 2.1 מיליארד, עוד סיבה לכך שקוד ספירה משתמש בטיפוס integer.

מה לקחת מכאן

• כל מספר מוקלד הוא double; 42L יוצר integer, ו-/ מחזיר double בכל מקרה.
• round() מעגל חצי לזוגי; floor/ceiling/trunc/signif כל אחת מקצצת אחרת, דעו לאיזו אתם מתכוונים.
• log() הוא הלוגריתם הטבעי; השתמשו ב-log10(), ב-log2() או ב-base = לבסיסים אחרים.
• %% נותן את השארית (הסימן לפי המחלק), %/% את המנה השלמה.
• 1/0 הוא Inf, 0/0 הוא NaN, ו-0.1 + 0.2 != 0.3: השוו מספרים עשרוניים עם all.equal(), אף פעם לא עם ==.

בהמשך: החצי השני של הנתונים היומיומיים, מחרוזות, והפונקציות ש-R נותן כדי לבנות, לעצב ולחפש בהן.