02-base-R.Rmd

# תחביר בסיסי {#sec-base-r}

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

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

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

## השמת משתנים, פעולות אריתמטיות ופונקציות

ניתן להריץ ב-R פעולות אריתמטיות (חיבור, חיסור, כפל, חילוק), פונקציות, ולהגדיר משתנים שונים. לדוגמה, הקוד הבא מגדיר משתנה `a` משתנה `b` ומכניס את הסכום שלהם למשתנה חדש שיקרא `a_plus_b`.

```{r sumab}
a <- 5
b <- 3
a_plus_b <- a + b
a_plus_b
```

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

```{r}
a_plus_b = a + b  # this form of assignment `=` is less common, don't use it (use `<-`)
```

### קביעת שמות משתנים

קודם השתמשנו בשמות `a`, `b` , ו-`a_plus_b` כדי לקבוע משתנים. ככלל, מומלץ להשתמש בשמות קצרים בעלי משמעות. שמות משתנים חייבים להתחיל באות באנגלית, ויכולים להכיל אותיות, מספרים, קו תחתון, ונקודה. לדוגמה `gender`, `age`, `raw_data`, וכו'.

### סוגי משתנים

בבסיס השפה יש כמה סוגי משתנים, שקובעים מה סוג הערכים שהמשתנה יכול לקבל:

-   מספר שלם (Integer)

-   מספר רציף (Double)

-   מחרוזת (Character)

-   משתנה קטגוריות (Factor)

-   תאריך (Date)

-   משתנה לוגי (Logical)

כל משתנה חדש אנחנו מגדירים ב-R הוא למעשה וקטור. אגב, גם כשאנחנו מגדירים משתנה כערך בודד, בעצם הוא וקטור עם איבר אחד. אנחנו יכולים להשתמש בפקודה `c` (קיצור של המילה combine) כדי לשלב וקטורים שונים.

נראה דוגמאות להגדרות של וקטורים מסוגים שונים.

```{r variable definition examples}
some_integer <- c(1L, 2L, 3L)  # The L sign stands for "Long integer"
some_integer

some_double <- c(1, 2, pi, exp(1))
some_double

some_character <- c("This", "is", "a", "character", "vector")
some_character

some_factor <- factor(c("Apples", "Oranges", "Paers", "Mangos", "Apples", "Oranges"))
some_factor

some_date <- c(Sys.Date(), as.Date("1993-08-01"))
some_date

some_logical <- c(TRUE, FALSE, FALSE, TRUE) # can also use c(T, F, F, T) is the same
some_logical
```

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

שימוש בפקודה `typeof(some_variable)` יציג את סוג המשתנה.

```{r using typeof}
typeof(some_integer)
typeof(some_double)
typeof(some_character)
typeof(some_date)
typeof(some_factor)
typeof(some_logical)
```

ניתן לשים לב ש-R מחשיב את המשתנה הקטגוריאלי כמספר שלם (integer) ואת התאריך כמספר רציף (double).

::: callout-tip
# תרגיל: חיבור של וקטורים מסוגים שונים

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

בדקו את `c(some_factor, some_character)` ודוגמאות נוספות.
:::

### קריאה לתתי וקטורים

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

```{r subsetting vectors}
some_factor[1:2]
some_character[c(1,4)]
```

## רשימה (list)

כעת נדון במבנה נתונים שנקרא רשימה (list). רשימה היא אובייקט מרכזי ב-R שמאפשר לנו לאחד משתנים ווקטורים מסוגים שונים, לתוך dataset שיאפשר לנו בהמשך לנתח נתונים. ישנן מספר דרכים להגדיר רשימה, אחת מהן באמצעות הפקודה `list`. לדוגמה, הרשימה הבאה תכיל את כל הוקטורים שהגדרנו עד כה, מבלי שהם יאבדו מהמשמעות שלהם (כפי שקורה כשמנסים לעשות חיבור רגיל).

```{r a complete list example}
my_list <- list(my_int = some_integer,
                my_double = some_double,
                my_character = some_character,
                my_factor = some_factor,
                my_date = some_date)
my_list
typeof(my_list)

```

כדי לקרוא לוקטור מסוים מתוך רשימה ניתן להשתמש ב-\$ באופן הבא:

```{r select out of a list}
my_list$my_int
```

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

```{r data frame demonstration}
my_data <- data.frame(name = c("Danny", "Moshe", "Iris", "Ronit"),
                      favorite_fruit = factor(c("Mango", "Apple", "Apple", "Paer")),
                      age = c(25L, 32L, 22L, 30L),
                      height = c(1.8, 1.75, 1.6, 1.68),
                      married = c(F, T, F, T))
my_data
typeof(my_data)
```

## שימוש בפונקציות

ניתן גם להפעיל פונקציות שונות, לדוגמה לוגריתם, פונקציות טריגונומטריות. למעשה בסעיף הקודם כבר ראינו מספר פונקציות כגון `c` ו-`typeof`. כעת נראה עוד מספר דוגמאות.

נסו להריץ את הקוד הבא, ולאחר מכן לענות על השאלות שלאחר מקטע הקוד. יש לשים לב שעל מנת להריץ את הפקודות בסוף המקטע (שקשורות ב-`my_data` נדרש קודם להגדיר את `my_data` כפי שהוגדר במקטע הקוד הקודם.

```{r functions-example, eval=FALSE}
log(100)  # natural logarithm
log10(100)  # base 10 logarithm 
sin(pi)  # sin(pi) is 0 but may give you a surprising answer, why?
sqrt(4)  # square root of 4
mean(my_data$age)
sd(my_data$age)
summary(my_data)
```

::: callout-tip
# חשיבה על דיוק

שאלה למחשבה: בחלק מהמחשבים התשובה שמתקבלת ל-`sin(pi)` שונה מ-0.

לדוגמה

```         
> sin(pi)
[1] 1.224606e-16
```

למה לדעתך?
:::

::: callout-tip
# הפקודה `summary`

הפקודה האחרונה שהרצנו בדוגמה היא פקודת summary. מה עושה הפקודה summary עבור כל סוג עמודה שהיא מוצאת בdata.frame?
:::

ככלל, הפעלת פונקציה ב-R תיראה כך:

```{r, eval=FALSE}
# some code which defines the variable `bar` and then
some_result <- some_function(foo = bar)

# or simply
some_result <- some_function(bar)
```

כאשר `some_result` יחזיק את התוצאה של הפונקציה. הפונקציה עצמה נקראת `some_function`, היא מקבלת ארגומנט (משתנה) יחיד שנקרא `foo` ואנחנו משתמשים במשתנה שערכו `bar` שנכנס לארגומנט.

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

```{r new_function_def}
# define a new function which adds a number
one_plus <- function(number){
  number + 1
}
# use the function:
one_plus(1)
one_plus(one_plus(1))
```

## אופרטורים

אופרטורים משמשים כדי להגדיר תנאים לוגיים שונים, לדוגמה אם אנחנו רוצים לבדוק את נכונותם של שני תנאים או יותר. ב-R נשתמש בתו כפול `||` כדי לציין "או" לוגי (or), ונשתמש בתו כפול `&&` על מנת לציין "וגם" לוגי (and).

```{r demonstration of logical operators}

a <- 5
b <- 6

(a < 3) && (b >= 3)
(a >= 5) || (b > 10)


```

ישנם גם פעולות לוגיות **וקטוריות**: כמו שניתן לחבר שני וקטורים, ניתן גם לבצע פעולות לוגיות איבר-איבר. פעולות אלו מבוצעות על ידי תו בודד: `|` או `&`.

```{r demonstration of vector logical operators}

v1 <- c(T, T, F, F)
v2 <- c(T, F, T, F)

v1 | v2
v1 & v2

```

::: callout-tip
# אופרטור `||` ו-`&&`

נסו לבחון מה קורה במקרה של `v1 || v2` או `v1 && v2`. מה החוקיות?
:::

אופרטור נוסף הוא אופרטור השלילה (not), נשתמש בתו `!` על מנת לייצג אותו. לדוגמה:

```{r not operator}
!c(T, F)
!v1
a==5
!(a==5)
```

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

```{r comparison}
a == b
c(1, 2, 3) == c(2, 1 , 3)
```

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

## התניות

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

המבנה הכללי של התניות יראה כך:

```{r, eval=FALSE}
if (condition1) {
  # some code which evaluates if condition1 == TRUE
} else if (condition2) {
  # some code which evaluates if condition1 == FALSE and condition2 == TRUE
} else {
  # some code which evaluates if condition1 == FALSE and condition2 == FALSE
}
```

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

```{r if demonstration}

some_value <- 100

if (is.numeric(some_value)) {
  cat("This is indeed a numeric value!")
} else {
  cat("This is not a numeric value!")
}

some_value <- "foobar"

if (is.numeric(some_value)) {
  cat("This is indeed a numeric value!")
} else {
  cat("This is not a numeric value!")
}

```

אפשר גם להשתמש בהתניות בתוך התניות, כלומר בתוך פקודת `if` להגדיר פקודת `if` נוספת.

::: callout-tip
# תרגיל בבניית פונקציה

נסו להרחיב את הדוגמה הקודמת, כך שבמידה ו-`some_value` הוא מספר המתחלק ב-2 אז יודפס "some_value is even" ובמידה ואינו מתחלק ב-2 יודפס "some_value is odd".

נסו למצוא יותר מדרך אחת לביצוע הרחבה זו.
:::

## לולאות

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

-   לולאות `for`
-   לולאות `while`
-   לולאות `repeat` `break` `next`
-   לולאות באמצעות תכנות פונקציונלי (כדוגמת פקודת `lapply`, או פקודות מחבילות אחרות כמו `map` שנמצאת בחבילת `purrr`)

עדיף להימנע ככל שניתן משימוש בכל סוגי הלולאות `for`, `while`, ו-`repeat` בעבודה עם `R`. לולאות אלו מאוד לא יעילות וזמן הריצה שלהן ארוך. תכנות פונקציונלי הוא יותר יעיל, אך דורש קצת יותר "התרגלות". בכל זאת, נדגים את אופן הפעולה של לולאת `for`.

על מנת להגדיר לולאת `for` עלינו להגדיר ראשית את טווח הפעולה של הלולאה. לדוגמה, לולאה שרצה על המספרים 1 עד 100 תוגדר באופן הבא:

```{r, eval=FALSE}
for (i in 1:100){
  # do some action
  # you can use i for that but don't have to
}
```

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

```{r}

fruits <- c("Mango", "Bannana", "Pineapple", "Orange", "Apple", "Prune", "Lemon", "Loquat")
my_garden <- c("Mango", "Orange", "Lemon", "Loquat")

for (current_fruit in fruits) {
  if (current_fruit %in% my_garden) {
    cat("\nI grow", current_fruit)
  } else {
    cat("\nI don't grow", current_fruit)
  }
}

```

::: callout-tip
# ההבדל בין `%in%` לבין `in`

בדוגמה הקודמת השתמשנו ב-`in` וגם ב-`%in%`.

`in` נחשבת מילת מפתח, בעוד ש-`%in%` נחשבת אופרטור. עמדו על ההבדלים ביניהן וכתבו מה המשמעות של כל אחת, ומה התפקיד שלה בקוד.
:::

נדגים גם כיצד ניתן להחליף לולאה באמצעות פעולה וקטורית, ובאמצעות נוסחה מתמטית. נניח שאנחנו רוצים לחשב סכום של טור הנדסי, כלומר הסכום של $1, q, q^2, q^3, \ldots$ כאשר $q<1$. נציג שלוש דרכים לבצע את הפעולה הזו: לולאה (הדרך הכי פחות יעילה), פעולה וקטורית (להיעזר בוקטור, כלומר מערך של מספרים), והדרך היעילה ביותר שהיא כמובן פשוט להשתמש בנוסחה של טור הנדסי ($\frac{1}{1-q}$).

```{r three ways to calculate geometric series}

q <- 1/2

series_sum_loop <- 0

for (element_i in 0:50){
  series_sum_loop <- series_sum_loop + q^element_i
}

series_sum_loop

series_sum_vector <- sum(q^(0:50))

series_sum_vector

series_sum_analytic <- 1/(1-q)

series_sum_analytic
  
```

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

::: callout-tip
# תרגיל בבניית סדרת פיבונצ'י

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

$$
1, 1, 2, 3, 5, 8, 13, 21, 34,\ldots
$$ היעזרו בקוד הבא על מנת לבנות לולאה שתדפיס את 50 האיברים הראשונים של סדרת פיבונצ'י. עליכם להשלים את הקוד במקומות בהם מופיע סימן שאלה.
:::

```{r, eval=FALSE}
# Fibonachi code exercise, fill in the blanks (where you see `?`)
total <- ?

element_i_minus1 <- 1
element_i_minus2 <- 1

for (? in 3:total){
  next_element <- element_i_minus1 + ?
  element_i_minus2 <- element_i_minus1
  ? <- next_element
  
  cat("\n", ?)
}

```

```{r fibonnachi solution, eval=FALSE, include=FALSE}
total <- 50

element_i_minus1 <- 1
element_i_minus2 <- 1

for (index in 3:total){
  next_element <- element_i_minus1 + element_i_minus2
  element_i_minus2 <- element_i_minus1
  element_i_minus1 <- next_element
  
  cat("\n", next_element)
}

```

## סיכום

בפרק זה למדנו את התחביר הבסיסי של שפת `R`.

-   ראינו כיצד עובדת השמת משתנים

-   למדנו על סוגי משתנים שונים

-   ראינו כיצד לקרוא לתתי וקטורים (חלק מוקטור)

-   למדנו על אובייקטים מסוג רשימה (list)

-   למדנו על פונקציות שונות - כיצד להפעיל אותן וכיצד להגדיר פונקציות חדשות

-   למדנו על אופרטורים (וגם, או, לא - NOT, והשוואה)

-   למדנו על התניות (אם... אז... אחרת)

-   למדנו על לולאות (מסוג `for`), והזכרנו סוגים נוספים.

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

::: end-page