Chapter 6 基本函式

{R} 有許多函式 (function), 函式是一種物件, 是指令的集合, 執行特定功能或運算工作的指令, 資料整理, 資料分析等, 透過函式, 擴展了 {R} 在程式語言的功能性與便利性. 函式內通常需輸入引數 (argument).

{R} 基本系統 (base) 提供了一部分常用函式, 而更多不同類型的函式, 則由許多不同的學者貢獻到 {R} 系統 (contribution) 中, 這些函數都是用 {R} 程式語言寫成的. 例如, 統計常用函式 mean(), var(), sd(), log() 等.

6.1 函式語法

一個函式內通常需輸入引數 (argument) 或是 統計公式, 統計模型, (formals). 引數可以是一個以上, 有些引數一定要輸入, 稱為 必要引數 (required argument), 有些引數可以不用輸入, 稱為 自選引數 (optional argument), 另外一種引數則為 省略引數 (ellipsis argument) 這三種引可以同時存在一個函式內, 引數可以是數值, 文字, 資料框架或 {R} 的任何物件. 例如, 函式 log() 指令:

log(x, base = exp(1))

log() 函式在 {R} 內設以自然數為底計算, 其中 x 為必備引數, 使用者必須自行輸入所要計算的數值作為引數值. 而 base = exp(1) 為選擇引數, 若使用者沒有輸入引數值, 函式 log() 內設以自然數 $e$ 為底, 當然, 使用者可以更動底數的設定值, 例如更動為以 $2$ 為底的獨度對數運算, log(x, base = 2).

## basic function
x.vec = c(1:5)
x.vec           # show x.vec
## [1] 1 2 3 4 5
mean(x = x.vec) # function mean() calculate mean, return a scalar
## [1] 3
var(x = x.vec)  # function mean() calculate variance
## [1] 2.5
sd(x.vec)       # function mean() calculate standard deviation
## [1] 1.581139
summary(x.vec)  # summarized statistics
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##       1       2       3       3       4       5
## log function
x.vec <- c(1, 2, 3, 4, 5)
log(x = x.vec)  # take log for all elements in vector x.vec
## [1] 0.0000000 0.6931472 1.0986123 1.3862944 1.6094379
log(x = x.vec, base = 2)
## [1] 0.000000 1.000000 1.584963 2.000000 2.321928

6.2 檢視的函式原始碼定義

{R} 函式的原始碼定義分成 S3 classes 函式與 S4 classes 函式, 許多時候, 可以在 {R} 輸入函式名稱, 檢視 S3 classes 的函式. 例如, function.name(), 查看函式的原始碼內容與計算過程. 有時必須使用 methods("function.name"), getAnywhere("function.name"), stats:::function.name 例如, 指令提示符號下輸入 sd, 查看函式 sd 的計算過程與引數.

## methods()
sd
## function (x, na.rm = FALSE) 
## sqrt(var(if (is.vector(x) || is.factor(x)) x else as.double(x), 
##     na.rm = na.rm))
## <bytecode: 0x000000001513ce68>
## <environment: namespace:stats>
t
## function (x) 
## UseMethod("t")
## <bytecode: 0x000000001be0d260>
## <environment: namespace:base>
methods(t)
##  [1] t,ANY-method            t,CsparseMatrix-method  t,dgCMatrix-method     
##  [4] t,dgeMatrix-method      t,diagonalMatrix-method t,dppMatrix-method     
##  [7] t,dsCMatrix-method      t,dspMatrix-method      t,dsTMatrix-method     
## [10] t,dsyMatrix-method      t,dtpMatrix-method      t,dtrMatrix-method     
## [13] t,dtTMatrix-method      t,indMatrix-method      t,lgeMatrix-method     
## [16] t,lspMatrix-method      t,lsTMatrix-method      t,lsyMatrix-method     
## [19] t,ltpMatrix-method      t,ltrMatrix-method      t,ltTMatrix-method     
## [22] t,Matrix-method         t,ngeMatrix-method      t,nspMatrix-method     
## [25] t,nsTMatrix-method      t,nsyMatrix-method      t,ntpMatrix-method     
## [28] t,ntrMatrix-method      t,ntTMatrix-method      t,pMatrix-method       
## [31] t,RsparseMatrix-method  t,sparseVector-method   t,TsparseMatrix-method 
## [34] t.data.frame            t.default               t.fractions*           
## [37] t.gtable*               t.trellis*              t.ts*                  
## [40] t.vctrs_sclr*           t.vctrs_vctr*          
## see '?methods' for accessing help and source code
methods(class = "ts")
##  [1] [             [<-           aggregate     as.data.frame cbind         coerce       
##  [7] cycle         diff          diffinv       filter        initialize    kernapply    
## [13] lines         Math          Math2         monthplot     na.omit       Ops          
## [19] plot          print         show          slotsFromS3   t             time         
## [25] window        window<-     
## see '?methods' for accessing help and source code

若要檢視 S4 classes 的函式, 可以使用 showClass("function.namme"), showMethods("function.namme"), getMethod("function.namme"), selectMethod(), existsMethod(), hasMethod(), removeClass(), removeMethod(), getClass(), getSlots(), slotNames(), slot(). 另外一種查看函式的原始碼內容與計算過程, 是下載原始碼使用文書處理軟體打開檔案檢視.

download.packages(pkgs = "package.name",
                  destdir = "C:/RData",
                  type = "source")

6.3 數列函式

{R} 有幾個產生數列的基本函式, 包含 :, sequence(), rep() 等.

6.3.1 數列函式: seq() 與 sequence()

在統計運算中, 常需要產生數列向量, 例如產生 [1,2,3,4,5], [1,3,5,7,9] 等等, 可以使用函式 : (冒號), seq() 或 sequence() 等產生數列向量.

## :
1:5
## [1] 1 2 3 4 5
5:1
## [1] 5 4 3 2 1
-1:3
## [1] -1  0  1  2  3

數列函式 seq() 或 sequence() 的指令, 不受限只有整數, 可以任產生何實數數列.

seq(from = 1, to = 1, 
    by = ((to - from)/(length.out - 1)),
    length.out = NULL, 
    along.with = NULL, ...)

from = 1 數列起始值
to = 1 數列結束值
by 數列每次增加值
length.out 數列長度 (元素數目)

## seq()
seq(from = 1, to = 5, by = 0.5)
## [1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
seq(1, 5, 0.5)
## [1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
seq(1, 5, length = 3)
## [1] 1 3 5
seq(from = 0, to = 1, by = 0.1)
##  [1] 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
seq(from = 0, to = 2, by = 0.33)
## [1] 0.00 0.33 0.66 0.99 1.32 1.65 1.98
sequence(c(3, 4, 5))
##  [1] 1 2 3 1 2 3 4 1 2 3 4 5

6.4 重複元素函式: rep()

另一個與 seq() 類似的函式 rep(), 可以產生相同重複元素的向量. 向量指令與其中引數分別為:

rep(x, times = 1, length.out = NA, each = 1)

x 使用者想要相同重複元素的數值向量.
times 數值向量 x 重複的次數.
each 數值向量 x 的每個元素重複的次數.
length.out = NA 數值向量 x 重複後的長度.

## rep()
rep(0, times = 3)
## [1] 0 0 0
rep(1, 5)
## [1] 1 1 1 1 1
x.vec <- c(4, 5, 6)
rep(x.vec, times = 2)
## [1] 4 5 6 4 5 6
rep(x.vec, each = 2)
## [1] 4 4 5 5 6 6
rep(x.vec, each = 2, times = 3)
##  [1] 4 4 5 5 6 6 4 4 5 5 6 6 4 4 5 5 6 6
rep(x.vec, times = c(2, 2, 2))
## [1] 4 4 5 5 6 6
rep(x.vec, times = c(1, 2, 3))
## [1] 4 5 5 6 6 6
rep(x.vec, each = 2, len = 4)    # first 4 only.
## [1] 4 4 5 5

6.5 算數函式 Arithmetic Computing Function

{R} 有許多內建的 算數函式 (arithmetic function), 包含指數, 對數, Gamma 函數, Beta 函數, 三角函數, 反三角函數, 雙曲函數, 反雙曲函數等等.

算數函式 Arithmetic Computing Function
符號	定義
-	減法運算 (Substraction, can be unary or binary)
+	加法運算 (Addition, can be unary or binary)
!	否定運算 (Unary not)
*	乘法運算 (Multiplication, binary)
/	除法運算 (Division, binary)
^	指數乘冪運算 (Exponentiation, binary)
%%	整數除法的餘數 (Modulus, binary)
%/%	整數除法的商數 (Integer divide, binary)
%*%	矩陣內積乘法 (Matrix product, binary)
%o%	矩陣外積乘法 (Outer product, binary)
%x%	矩陣 Kronecker 乘法 (Kronecker product, binary)
%in%	配對運算 (Matching operator, binary, in model formulae: nesting)
`round(x, digits = 0)`	設定小數位數 (數值會受到作業系統影響)
`signif(x, digits = 6)`	設定實數列印出的小數位數 (數值會受到作業系統影響)
`trunc(x)`	將 `x` 的小數截斷, 向 0 靠近
`ceiling(x)`	大於 `x` 的最小整數
`floor(x)`	小於 `x` 的最大整數
`sign(x)`	求 `x` 的正負值, 回傳 1, 0, 或 -1.
`abs(x)`	求 `x` 的絕對值
`sqrt(x)`	$\sqrt{x}$
`exp(x)`	$e^x$
`expm1(x)`	當 $\vert x \vert \ll 1$, 計算 $e^{x}-1$
`log(x)`	$\log (x)$
`log10(x)`	$\log_{10} (x)$
`log2(x)`	$\log_2 (x)$
`logb(x, base = z)`	$\log_z (x)$
`log1p(x)`	當 $\vert x \vert \ll 1$, 計算 $\log(1+x)$
`gamma(x)`	$\Gamma (x) = (x-1)! = \int_0^\infty t^{(x-1)} \exp (-t) d t$
`lgamma(x)`	$\log_e [\Gamma (x)]$
`beta(a, b)`	$B (a,b) = (\Gamma (a) \Gamma (b))\,/\, (\Gamma(a+b))$
	$ = _0^1 t^{(a-1)} (1-t)^{(b-1)} d t$
`lbeta(a, b)`	$\log_e [B(a, b)]$
`digamma(x)`	$\frac{d}{dx} \log_e [\Gamma (x)]$
`trigamma(x)`	$\frac{d^2}{d x^2} \log_e [\Gamma (x)]$
`psigamma(x, deriv = 0)`	$\frac{d^p}{d x^p} \log_e [\Gamma (x)]$
`sin(x) cos(x) tan(x)`	三角函數 (trigonometric functions)
`asin(x) acos(x) atan(x)`	反三角函數 (inverse functions)
`sinh(x) cosh(x) tanh(x)`	雙曲函數 (hyperbolic functionsx)
`asinh(x) acosh(x) atanh(x)`	反雙曲函數 (inverse hyperbolic functions)

## Arithmetic Computing
## rounding
(x.vec <- 0.5 + c(-2:2))
## [1] -1.5 -0.5  0.5  1.5  2.5
round(x.vec) # IEEE rounding
## [1] -2  0  0  2  2
(y.vec <- seq(-2, 2, by = 0.5))
## [1] -2.0 -1.5 -1.0 -0.5  0.0  0.5  1.0  1.5  2.0
(y.round <- round(y.vec)) # IEEE rounding
## [1] -2 -2 -1  0  0  0  1  2  2
(y.trunc <- trunc(y.vec))
## [1] -2 -1 -1  0  0  0  1  1  2
(y.signif <- signif(y.vec))
## [1] -2.0 -1.5 -1.0 -0.5  0.0  0.5  1.0  1.5  2.0
(y.ceil <- ceiling(y.vec))
## [1] -2 -1 -1  0  0  1  1  2  2
(y.floor <- floor(y.vec))
## [1] -2 -2 -1 -1  0  0  1  1  2
cbind(y.vec, y.round, y.trunc, y.signif, y.ceil, y.floor)
##       y.vec y.round y.trunc y.signif y.ceil y.floor
##  [1,]  -2.0      -2      -2     -2.0     -2      -2
##  [2,]  -1.5      -2      -1     -1.5     -1      -2
##  [3,]  -1.0      -1      -1     -1.0     -1      -1
##  [4,]  -0.5       0       0     -0.5      0      -1
##  [5,]   0.0       0       0      0.0      0       0
##  [6,]   0.5       0       0      0.5      1       0
##  [7,]   1.0       1       1      1.0      1       1
##  [8,]   1.5       2       1      1.5      2       1
##  [9,]   2.0       2       2      2.0      2       2
#
(x.vec <-  0.5 + c(-2:3))
## [1] -1.5 -0.5  0.5  1.5  2.5  3.5
round(x.vec) # IEEE rounding
## [1] -2  0  0  2  2  4
(y.vec <- seq(-2, 3, by = 0.5))
##  [1] -2.0 -1.5 -1.0 -0.5  0.0  0.5  1.0  1.5  2.0  2.5  3.0
(y.round <- round(y.vec)) # IEEE rounding
##  [1] -2 -2 -1  0  0  0  1  2  2  2  3
(y.trunc <- trunc(y.vec))
##  [1] -2 -1 -1  0  0  0  1  1  2  2  3
(y.signif <- signif(y.vec))
##  [1] -2.0 -1.5 -1.0 -0.5  0.0  0.5  1.0  1.5  2.0  2.5  3.0
(y.ceil <- ceiling(y.vec))
##  [1] -2 -1 -1  0  0  1  1  2  2  3  3
(y.floor <- floor(y.vec))
##  [1] -2 -2 -1 -1  0  0  1  1  2  2  3
cbind(y.vec, y.round, y.trunc, y.signif, y.ceil, y.floor)
##       y.vec y.round y.trunc y.signif y.ceil y.floor
##  [1,]  -2.0      -2      -2     -2.0     -2      -2
##  [2,]  -1.5      -2      -1     -1.5     -1      -2
##  [3,]  -1.0      -1      -1     -1.0     -1      -1
##  [4,]  -0.5       0       0     -0.5      0      -1
##  [5,]   0.0       0       0      0.0      0       0
##  [6,]   0.5       0       0      0.5      1       0
##  [7,]   1.0       1       1      1.0      1       1
##  [8,]   1.5       2       1      1.5      2       1
##  [9,]   2.0       2       2      2.0      2       2
## [10,]   2.5       2       2      2.5      3       2
## [11,]   3.0       3       3      3.0      3       3
#
(y.vec <- seq(-2, 3, by = 0.5))
##  [1] -2.0 -1.5 -1.0 -0.5  0.0  0.5  1.0  1.5  2.0  2.5  3.0
y.vec[trunc(y.vec) != floor(y.vec)]
## [1] -1.5 -0.5
y.vec[round(y.vec) != floor(y.vec + 0.5)]
## [1] -1.5  0.5  2.5
#
(z.vec <- pi * 100 ^ (-1:3))
## [1] 3.141593e-02 3.141593e+00 3.141593e+02 3.141593e+04 3.141593e+06
round(z.vec, 3)
## [1]       0.031       3.142     314.159   31415.927 3141592.654
signif(z.vec, 3)
## [1] 3.14e-02 3.14e+00 3.14e+02 3.14e+04 3.14e+06
#
## sign() abs()
sign(pi) # == 1
## [1] 1
sign(-2:3)# -1 -1 0 1 1 1
## [1] -1 -1  0  1  1  1
abs(-2:3)
## [1] 2 1 0 1 2 3
#
## log(), exp() calculation
(x.vec <- 1:3)
## [1] 1 2 3
log(exp(x.vec))
## [1] 1 2 3
(y.vec <- 10^(x.vec))
## [1]   10  100 1000
log10(y.vec)
## [1] 1 2 3
log10(1e7) # = 7
## [1] 7
#
## options(digits, scipen)
(z.vec <- pi * 100 ^ (-1:3)) # without change options
## [1] 3.141593e-02 3.141593e+00 3.141593e+02 3.141593e+04 3.141593e+06
options(digits = 4, scipen = 0)
z.vec <- pi * 100^(-1:3)
print(z.vec / 1000, digits = 4)
## [1] 3.142e-05 3.142e-03 3.142e-01 3.142e+01 3.142e+03
options(digits = 4, scipen = 100)
print(z.vec / 1000, digits = 4)
## [1]    0.00003142    0.00314159    0.31415927   31.41592654 3141.59265359
#
options(digits = 4, scipen = 100)
x.vec <- 100 ^ -(1 + 2 * 1:3)
cbind(
  x = x.vec,
  log1px = log(1 + x.vec),
  log1p  = log1p(x.vec),
  exp    = exp(x.vec) - 1,
  expm1  = expm1(x.vec)
)
##                     x               log1px            log1p                  exp
## [1,] 0.00000100000000 0.000000999999499918 0.00000099999950 0.000001000000499962
## [2,] 0.00000000010000 0.000000000100000008 0.00000000010000 0.000000000100000008
## [3,] 0.00000000000001 0.000000000000009992 0.00000000000001 0.000000000000009992
##                 expm1
## [1,] 0.00000100000050
## [2,] 0.00000000010000
## [3,] 0.00000000000001
#
options(digits = 4, scipen = 0)
x.vec <- 100^(-(1 + 2 * 1:3))
cbind(
  x = x.vec,
  log1px = log(1 + x.vec),
  log1p  = log1p(x.vec),
  exp    = exp(x.vec) - 1,
  expm1  = expm1(x.vec)
)
##          x    log1px log1p       exp expm1
## [1,] 1e-06 1.000e-06 1e-06 1.000e-06 1e-06
## [2,] 1e-10 1.000e-10 1e-10 1.000e-10 1e-10
## [3,] 1e-14 9.992e-15 1e-14 9.992e-15 1e-14

6.6 組合與階乘函式: choose() 與 factorial()

{R} 內建的組合與階乘函式 choose(), lchoose(), factorial(), lfactorial(), 其用法類似.

choose(n, k) = $\binom{n}{k}$
fractorial(x) = $x!$
k 為正整數.
x 與 n 為數值向量.
factorial(), lfactorial() 回傳原始結果取對數值.

## combination
## choose()
choose(n = 5, k = 2)
## [1] 10
log(choose(n = 5, k = 2))
## [1] 2.303
lchoose(n = 5, k = 2)
## [1] 2.303
for (n in 0:5)
  print(choose(n, k = 0:n))
## [1] 1
## [1] 1 1
## [1] 1 2 1
## [1] 1 3 3 1
## [1] 1 4 6 4 1
## [1]  1  5 10 10  5  1
## factorial
factorial(x = 100)
## [1] 9.333e+157
log(factorial(x = 100))
## [1] 363.7
lfactorial(x = 100)
## [1] 363.7
lfactorial(x = 10000)
## [1] 82109
factorial(x = c(1, 3, 5))
## [1]   1   6 120

6.7 選擇資料函式: all(), any(), which()

函式 all(x) 與 any(x) 可以用來查看特定向量物件 obj.vec 的元素是否符合某些特定條件, 回傳邏輯純量 TRUE 或 FALSE. 函式 which() 查看特定向量物件 obj.vec 的元素是否符合某些特定條件, 然後回傳一個下標向量, 紀錄向量物件符合某些特定條件的元素位置. 函式指令 which.max() 與 which.min() 是函式指令 which() 的延伸.

all(..., na.rm = FALSE)
any(..., na.rm = FALSE)
which(x, arr.ind = FALSE, useNames = TRUE)

其中 ... 為輸入向量物件的條件判斷. all(x) 與 any(x) 回傳一個純量 (scalar) 代表 TRUE 或 FALSE. 使用函式 all(x) 用來檢查邏輯向量 $\mathbf{x}$ 的所有元素是否都是 TRUE? 另一方面, 使用函式 any(x) 用來檢查邏輯向量 $\mathbf{x}$ 的任一元素是否為 TRUE? 使用函式指令 which(x) 則回傳一個向量, 是邏輯向量 $\mathbf{x}$ 中的元素為 TRUE 所在的下標位置 (index). which(x) 可使用引數 arr.ind = TRUE 是當 $\mathbf{x}$ 為 array (matrix) 時, 回傳 array (matrix) 的下標位置.

## all(), any(), which()
(x.vec <- c(-1:2))
## [1] -1  0  1  2
all(x.vec > 0)
## [1] FALSE
any(x.vec > 0)
## [1] TRUE
which(x.vec > 0)
## [1] 3 4
which.max(x.vec)
## [1] 4
which.min(x.vec)
## [1] 1
#
(x.mat <- matrix(c(2, -1, -3,
                   -1,  2,  4,
                   -3,  4,  9),
                 nrow = 3, byrow = T))
##      [,1] [,2] [,3]
## [1,]    2   -1   -3
## [2,]   -1    2    4
## [3,]   -3    4    9
all(x.mat > 0)
## [1] FALSE
any(x.mat > 0)
## [1] TRUE
which(x.mat > 0)
## [1] 1 5 6 8 9
#
which(x.mat %% 2 == 0)
## [1] 1 5 6 8
which(x.mat %% 2 == 0, arr.ind = TRUE)
##      row col
## [1,]   1   1
## [2,]   2   2
## [3,]   3   2
## [4,]   2   3

6.8 排序函式 Ranking and Sorting

在 {R} 中有數個與排序相關的函式, 如 rev(), sort(), order() 與 rank().

常見之排序函式
函式	說明
`rev(x)`	將向量 $\mathbf{x}$ 元素反轉列出 (reverse order)
`rank(x)`	向量 $\mathbf{x}$ 元素的對應排序 (returns the sample ranks of the values)
	相同數值內設排序方式 `ties.method = "average"`
`sort(x)`	向量 $\mathbf{x}$ 從小到大列出 (sort a vector or factor, partially)
	into ascending or descending order).
`order(x)`	將向量 $\mathbf{x}$ 從小到大排序後的向量之元素

rev(x)
sort(x, decreasing = FALSE, na.last = NA, ...)
rank(x, na.last = TRUE,
     ties.method = c("average", "first", "last", "random", "max", "min"))
order(x, ..., na.last = TRUE, decreasing = FALSE,
        method = c("shell", "radix"))

這些函式的共用引數為:

引數 x 為向量 $\mathbf{x}$.
引數 decreasing:
- decreasing = FALSE 為 {R} 內設從小到大排序.
- decreasing = TRUE 則從大到小排序.
引數 na.last:
- na.last = TRUE 為 {R} 內設將 NA 排序在最大.
- na.last = FALSE 為 {R} 內設將 NA 排序在最小.
- na.last = NA 為 {R} 內設將 NA 排除.
函式 rev(x) 回傳一個向量 $\mathbf{z}$, 是將向量 $\mathbf{x}$ 元素反轉.
函式 sort(x) 回傳一個向量 $\mathbf{z}$, 是將向量 $\mathbf{x}$ 的元素從小到大排序的結果列出.
函式 rank(x) 回傳一個向量 $\mathbf{z}$, 是將向量 $\mathbf{x}$ 每一個元素從小到大排序之後, $\mathbf{x}$ 元素之相對順序 (rank).
"average": 相同數值都是回傳平均排序值.
"first": 相同數值都是回傳依序由小到大不同排序值.
"last": 相同數值都是回傳依序由大到小排序值.
"random": 相同數值回傳隨機排序值.
"max": 相同數值回傳最大排序值.
"min": 相同數值回傳最小排序值.

## reverse, rank, sort and order
## rev(): reverse elements
x.vec <- c(7, 7, 7, 6, 10, 9, 9, 9, NA, 8)
rev(x.vec)
##  [1]  8 NA  9  9  9 10  6  7  7  7
## sort(): from the smallest to the largest
sort(x.vec)
## [1]  6  7  7  7  8  9  9  9 10
## rank():
rank(x.vec, na.last = TRUE)
##  [1]  3  3  3  1  9  7  7  7 10  5
rank(x.vec, na.last = FALSE)
##  [1]  4  4  4  2 10  8  8  8  1  6
set.seed(1)
rank(x.vec, ties.method = "average")
##  [1]  3  3  3  1  9  7  7  7 10  5
rank(x.vec, ties.method = "first")
##  [1]  2  3  4  1  9  6  7  8 10  5
rank(x.vec, ties.method = "last")
##  [1]  4  3  2  1  9  8  7  6 10  5
rank(x.vec, ties.method = "random")
##  [1]  2  3  4  1  9  7  8  6 10  5
rank(x.vec, ties.method = "max")
##  [1]  4  4  4  1  9  8  8  8 10  5
rank(x.vec, ties.method = "min")
##  [1]  2  2  2  1  9  6  6  6 10  5
## order(): retrun index
## x.vec[] is the smallest one
order(x.vec)
##  [1]  4  1  2  3 10  6  7  8  5  9
x.vec[order(x.vec)]
##  [1]  6  7  7  7  8  9  9  9 10 NA
## rank(): ties.method = "average"
x <- c(7, 9, 6, 7, 8, NA)
sort(x, na.last = FALSE)
## [1] NA  6  7  7  8  9
rank(x, ties.method = "average", na.last = TRUE)
## [1] 2.5 5.0 1.0 2.5 4.0 6.0
(x.ord <- order(x, na.last = FALSE))
## [1] 6 3 1 4 5 2
x[x.ord] # = sort(x)
## [1] NA  6  7  7  8  9

{R} 排序對缺失值 NA 處理要非常小心, 引數 na.last = TRUE 為 {R} 內設, 但在比較關係上, 對缺失值 NA 可有不同處理.

6.9 物件查看與強制轉換函式

{R} 的許多函式型式為 is.object(), 例如函式 is.na(), is.vector() 等, 可以用來查看某一特定物件是否屬於某一類別.

{R} 的許多函式型式為 as.object(), 例如函式 as.vector(), as.matrix() 等, 可以用來某強制轉換一特定物件到所指定的物件類別.

## is() and as()
# vector
x.vec <- c(1 / 1, 1 / 2, 1 / 3, 1 / 4, 1 / 5)
x.vec
## [1] 1.0000 0.5000 0.3333 0.2500 0.2000
is.vector(x.vec)
## [1] TRUE
is.character(x.vec)
## [1] FALSE
x.vec <- as.character(x.vec)
x.vec
## [1] "1"                 "0.5"               "0.333333333333333" "0.25"             
## [5] "0.2"
##
b.df <- as.data.frame(matrix(c(1:24), nrow = 6, byrow = T))
is.matrix(b.df)
## [1] FALSE
b.mat <- as.matrix(b.df)
b.mat
##      V1 V2 V3 V4
## [1,]  1  2  3  4
## [2,]  5  6  7  8
## [3,]  9 10 11 12
## [4,] 13 14 15 16
## [5,] 17 18 19 20
## [6,] 21 22 23 24
b.mat <- as.vector(b.mat)
b.mat
##  [1]  1  5  9 13 17 21  2  6 10 14 18 22  3  7 11 15 19 23  4  8 12 16 20 24

函式	說明
`rev(x)`	將向量 \(\mathbf{x}\) 元素反轉列出 (reverse order)
`rank(x)`	向量 \(\mathbf{x}\) 元素的對應排序 (returns the sample ranks of the values)
	相同數值內設排序方式 `ties.method = "average"`
`sort(x)`	向量 \(\mathbf{x}\) 從小到大列出 (sort a vector or factor, partially)
	into ascending or descending order).
`order(x)`	將向量 \(\mathbf{x}\) 從小到大排序後的向量之元素