Vector, Data types, if-else (W3)

vector

• 上週實習課使用 R 時，指令的回傳值多半只有「一個」。但 R 其實是一種以向量作為基本單位的程式語言，所以對於「一個回傳值」更精確的描述應該是「一個長度為 1 的向量」。

  x <- 2
  x
  
  is.vector(x)
  length(x)

  #> [1] 2
  #> [1] TRUE
  #> [1] 1

• 我們上週簡短提過以 : 製造數列的方式 (e.g. 1:10)。事實上，這個回傳的數列即是一個 vector。另外，由於這個 vector 的每個元素皆是整數，因此這個 vector 屬於 integer vector。我們可以使用 typeof() 確認 vector 的類別

  typeof(1:10)

  #> [1] "integer"

• R 裡面的 vector 可以被分成 6 種類別，其中常見的 4 種分別為 integer, double, , character, logical

integer vector

• integer vector 的元素由整數組成，它可以是零、正或負的。除了使用 : 製造數列，也可以使用 c() (稱為 concatenate) 組出任意序列的 vector。
  • 使用 c() 製造 integer vector 時，每個整數數字後面必須接 L，若沒有加上 L， R 會將製造出來的 vector 視為 double vector。

int_vec <- c(-1L, 5L, 2L)
dbl_vec <- c(-1, 5, 2)
int_vec
dbl_vec

typeof(int_vec)
typeof(dbl_vec)

#> [1] -1  5  2
#> [1] -1  5  2
#> [1] "integer"
#> [1] "double"

double vector

• double vector 儲存的是浮點數，亦即含有小數點的數字 (e.g 1.2, -0.75)

• 在 R 裡面，integer vector 與 double vector 合稱為 numeric vector，兩者之間的區隔通常也不太重要，因為 R 在運算時，通常會將這兩種資料類型自動轉換成合適的類型

  typeof(2L)
  typeof(2.0)
  
  is.numeric(2L)
  is.numeric(2.0)

  #> [1] "integer"
  #> [1] "double"
  #> [1] TRUE
  #> [1] TRUE

  typeof(1L + 1.0)
  typeof(1L / 2L)

  #> [1] "double"
  #> [1] "double"

• Special values:
  • Inf: 代表無限大

  • NaN: “Not a Number”，常見於數字運算不符數學定義時，例如：

    0 / 0
    Inf / Inf
    log(-1)

    #> Warning in log(-1): NaNs produced

    #> [1] NaN
    #> [1] NaN
    #> [1] NaN

character vector

• 除了數字以外，R 也可以儲存字串 (string)。character vector 的每個元素皆由一個字串所組成。在 R 裡面，只要是被引號 (quote, ' 或 " 皆可) 包裹的東西就是字串，放在引號內的可以是任何字元 (e.g. 空白、數字、中文字、英文字母)

  "1.1"  # This is a string (or character vector of length 1), not double
  "你 好！"
  c("1.1", "你 好！")

  #> [1] "1.1"
  #> [1] "你 好！"
  #> [1] "1.1"     "你 好！"

• 如果字串內含有引號 "，需在字串內的引號前使用跳脫字元 \，以表示此引號是字串的一部分而非字串的開頭或結尾
  • 或是，你可以使用「不同的」引號。例如以「單引號」表示字串的開頭與結尾時，字串內就可以直接使用「雙引號」，反之亦然

  "\""  # escape a double quote
  '\''  # escape a single quote
  '"'   # a double quote as string without escaping
  "'"   # a single quote as string without escaping

  #> [1] "\""
  #> [1] "'"
  #> [1] "\""
  #> [1] "'"

logical vector

• logical vector 的每個元素由 TRUE 或 FALSE 組成。

• 可以使用 c() 一項項手動輸入製造 logical vector

• logical vector 的另一個來源則是 logical test 的回傳值：
  • logical operators: ==, !=, >, <, %in%
    

  vec1 <- c(1, 1, 1)
  vec2 <- c(2, 0, 2)

  # logical tests
  vec1 > vec2
  vec1 < vec2
  vec1 == vec2

  #> [1] FALSE  TRUE FALSE
  #> [1]  TRUE FALSE  TRUE
  #> [1] FALSE FALSE FALSE

• boolean operators (&, |, !, any(), all()) 可以整合多個 logical tests
  

  TRUE & TRUE
  TRUE & FALSE
  TRUE | FALSE
  !TRUE

  #> [1] TRUE
  #> [1] FALSE
  #> [1] TRUE
  #> [1] FALSE

  (1 == 1) & (2 == 2)

  #> [1] TRUE

NA

• NA 代表的是「缺失值」，可以作為任何一種 vector 裡面的元素。當 NA 出現在 vector 中，函數對於 vector 的運算常會出現令人意外的結果:

  10 > NA

  #> [1] NA

  NA == NA

  #> [1] NA

  vec <- c(1, NA, 2, 3)
  mean(vec)

  #> [1] NA

  mean(vec, na.rm = TRUE)

  #> [1] 2

Recycling

• 兩個或兩個以上的 vector 進行運算時，通常是以 element-wise 的方式進行。此時，若進行運算的 vector 長度不相同，例如，c(1, 2, 3) + 2， R 會自動將長度較短 vector (2) 「回收 (recycle)」，亦即，重複此向量內的元素使其「拉長」到與另一個 vector 等長；接著再將兩個一樣長的 vector 進行 element-wise 的向量運算。

x <- c(1, 1, 2, 2)

# Arithmetic operation
x + 2  # equivalent to...
x + c(2, 2, 2, 2)

#> [1] 3 3 4 4
#> [1] 3 3 4 4

x <- c(1, 1, 2, 2)

# Logical operation
x == 2  # equivalent to...
x == c(2, 2, 2, 2)

#> [1] FALSE FALSE  TRUE  TRUE
#> [1] FALSE FALSE  TRUE  TRUE

# String operation
long <- c("a", "b", "c")
short <- "1"
paste0("a", "1")
paste0(long, short)

#> [1] "a1"
#> [1] "a1" "b1" "c1"

Coercion

• vector 內的每個元素，其資料類型 (data type) 必須相同。資料類型即是前面提到的 integer, double, character, logical。

• 若發生資料類型不一致的情形 (e.g. 將不同資料類型的元素放入 c())，R 會根據某些規則，自動進行資料類型的轉換。這個過程在 R 裡面稱為 Coercion

  c(TRUE, FALSE, 3)      # logical & numeric
  c(-1, "aa")            # numeric & character
  c(FALSE, TRUE, "hi!")  # logical & character
  c(TRUE, 0, "hi!")      # logical & numeric & character

  #> [1] 1 0 3
  #> [1] "-1" "aa"
  #> [1] "FALSE" "TRUE"  "hi!"  
  #> [1] "TRUE" "0"    "hi!"

Rules of Coercion

• if coercion failed, throw error

• manual coercion: as.character(), as.logical(), as.numeric()

sum(c(T, T, T, F))

gender <- c("male", "female", "male", "female")
sum(gender == "male")  # num of male
mean(gender == "male")  # proportion of male

#> [1] 3
#> [1] 2
#> [1] 0.5

Subsetting a vector

• 有 3 種方法可用於取出 vector 裡面的元素 (回傳一個新的 vector)
  1. 透過提供 vector 中元素的位置次序 (index)
  2. 透過一個與此 vector 等長的 logical vector。在 logical vector 中的相對應位置，以 TRUE 或 FALSE 表示是否保留該位置的元素
  3. 透過提供元素的「名字」(i.e. names 屬性)

index subsetting

# z[<integer_vector>]
LETTERS  # R 內建變數: 包含所有大寫英文字母的 character vector

#>  [1] "A" "B" "C" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q"
#> [18] "R" "S" "T" "U" "V" "W" "X" "Y" "Z"

LETTERS[1]

#> [1] "A"

LETTERS[1:5]

#> [1] "A" "B" "C" "D" "E"

LETTERS[c(1, 3, 5)]

#> [1] "A" "C" "E"

LETTERS[-(1:5)]  # Exclude the first 5 elements

#>  [1] "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q" "R" "S" "T" "U" "V"
#> [18] "W" "X" "Y" "Z"

Logical subsetting

# z[<logical_vector of length(z)>]
age <- c(21, 20, 18, 19)
age[c(FALSE, TRUE, FALSE, TRUE)]

#> [1] 20 19

## Creating logical vectors
age[1] < 20  # returns a logical vector of length 1

#> [1] FALSE

age < 20     # returns a logical vector of length(x)

#> [1] FALSE FALSE  TRUE  TRUE

# Subset a vector using a logical test
age[age < 20]

#> [1] 18 19

Subsetting with names

age <- c(40, 20, 18, 19)
names(age) <- c("kai", "jessy", "joy", "yola")
# age <- c(kai = 40, jessy = 20, joy = 18, yola = 19)  # another way of setting names

age

#>   kai jessy   joy  yola 
#>    40    20    18    19

age['kai'] + 9

#> kai 
#>  49

age[c('jessy', 'kai')]

#> jessy   kai 
#>    20    40

Modifying Values in vector

a2z <- LETTERS
a2z[1:3] <- c("a", "b", "c")
a2z

#>  [1] "a" "b" "c" "D" "E" "F" "G" "H" "I" "J" "K" "L" "M" "N" "O" "P" "Q"
#> [18] "R" "S" "T" "U" "V" "W" "X" "Y" "Z"

gender <- c("m", "m", "f", "f")
gender[gender == "m"] <- "male"
gender

#> [1] "male" "male" "f"    "f"

gender[gender == "f"] <- "female"
gender

#> [1] "male"   "male"   "female" "female"

names(gender) <- c("john", "jenny", "jane", "kate")
gender

#>     john    jenny     jane     kate 
#>   "male"   "male" "female" "female"

gender["john"] <- "male"
gender

#>     john    jenny     jane     kate 
#>   "male"   "male" "female" "female"

gender[c("jenny", "jane", "kate")] <- "female"
gender

#>     john    jenny     jane     kate 
#>   "male" "female" "female" "female"

---

if else

• 一般而言，R 是由上至下一行一行地執行程式碼。有時候我們會希望能跳過某些程式碼或是依據不同的狀況執行不同的程式碼，這時候我們就需要使用條件式。

x <- 1

if (x > 0) {
    print('x is positive')
} else {
    print('x is not positive')
}

#> [1] "x is positive"

x <- -1

if (x > 0) {
    print('x is positive')
} else if (x < 0) {
    print('x is negative')
} else {
    print('x is zero')
}

print('This is always printed')

#> [1] "x is negative"
#> [1] "This is always printed"

• 在 if-else if-else 的結構中，只有其中一個區塊 (被大括弧 {} 包裹的程式碼) 會被執行。執行完該區塊後，就會忽略剩下的條件控制區塊，執行條件式之後的程式碼。

• 可以在 if 之後使用多個 else if.

• 條件式的結構：

  # 只有 if
  if (<條件>) {
      <Some Code>  # 條件成立時執行
  }
  
  # if, else
  if (<條件>) {
      <Some Code>  # <條件>成立時執行
  } else {
      <Some Code>  # <條件>不成立時執行
  }
  
  # if, else if, else
  if (<條件1>) {
      <Some Code>          # <條件1>成立時執行
  } else if ( <條件2> ) {
      <Some Code>          # <條件1>不成立、<條件2>成立時執行
  } else {
      <Some Code>          # <條件1>、<條件2>皆不成立時執行
  }

Wrap up: 句子產生器

# Data
name <- c("kai", "jessy", "joy", "yola")
age <- c(40, 20, 18, 19)
about <- c("a professor", "a cat lover", "a hacker", "a YouTuber")

# Randomly draw 2 subjects
draws <- sample(1:4, size = 2)

# Find out who is older
if (age[draws[1]] > age[draws[2]]) {
    comparitive <- 'is older than'
} else if (age[draws][1] < age[draws][2]) {
    comparitive <- 'is younger than'
} else {
    comparitive <- 'is the same age as'
}

# Construct sentence
roles <- paste0(name[draws], ", " , about[draws])
roles

#> [1] "yola, a YouTuber" "joy, a hacker"

paste0(roles[1], ", ", comparitive, " ", roles[2], ".")

#> [1] "yola, a YouTuber, is older than joy, a hacker."

配合課本

• Hands-on programming with R
  • R Objects
  • Modifying Values