class: title-slide-section, center, middle
name: logistics
# はじめに


- Rのプログラミングに関する入門事項についての解説。

- 注意：暫く更新していないため、タイポやエラーなどが多々ある可能性。

- 謝辞：本スライドは [Applied Statistics with R](https://daviddalpiaz.github.io/appliedstats/) に基づいています。


---
class: title-slide-section, center, middle
name: logistics
# データ

---
## データ型

`R` はいくつもデータの*型*をもつ。

- Numeric（数値型）
    - `R` には Integer（整数型）と Double（実数型）がある。数値を扱うときの基本の型である。
    - Examples: `1`, `1.0`, `42.5`
    
- Logical（論理型）
    - `TRUE` と `FALSE` の真偽二値のみとる。
    -  `T` と `F` とも書けるが、**非推奨**。
    - ``R` では `NA` も logical である。
    
- Character（文字型）
    - 例：`"a"`/`"Statistics"`/`"1 plus 2."`
    
---
## データ構造

- `R` は基本的な*データ構造*をもつ。
- データ構造は以下のいずれもある。
    - 同質的（全ての要素が同じデータ型をもつ）
    - 異質的 （要素が異なるデータ型をもつ）


| 次元 | **同質的** | **異質的** |
|-----------|-----------------|-------------------|
| 1         | ベクトル（vector）| リスト（list）   |
| 2         | 行列（matrix）       | データフレーム（data frame）|
| 3+        | 配列（array）        |                   |


---
class: title-slide-section, center, middle
name: logistics
# ベクトル

---
## ベクトル

**ベクトルの基本**

- `R` における多くの操作で**ベクトル**を使う。
    - `R` の**添字は 1 からはじまる。**
- `R` でベクトルを作成するのによく用いられるのは`c()` である（combine の略）。

```{r}
c(1, 3, 5, 7, 8, 9)
```


---
## 代入

- ベクトルを**変数**に格納したければ、**代入演算子（assignment operator）** `=` を用いる。
    - 変数 `x` にベクトルを格納しているので、`x` と入力すればベクトルをよびだせる。

```{r}
x = c(1, 3, 5, 7, 8, 9)
x
# 次も同じ
x <- c(1, 3, 5, 7, 8, 9)
x
```

---
## 代入に関するTips

- `R` では `=` と `<-` が代入演算子として問題なく使える（大体の場合は）。
    - 問題になる例は [The R Inferno](http://www.burns-stat.com/documents/books/the-r-inferno/) を参照。
- `R` では、行の先頭に `#` をつけるとコメント行としてみなされ、実行されない。
 

---
## 数字の列

- 数列の作成には `:` 演算子を使うのが最もお手軽である。

```{r}
(y = 1:100)
```

- かっこをつけると、`R` は
    - 変数 `y` に数列を格納する。
    - 変数 `y` をコンソールに表示する。

---
## ベクトル作成に便利な関数

- 数列の作成には `seq()` 関数の汎用性が高い。

```{r}
seq(from = 1.5, to = 4.2, by = 0.1)
```

- `from`・`to`・`by` はあってもなくてもよい（optional）。 

```{r}
seq(1.5, 4.2, 0.1)
```

---
## 続・ベクトル作成に便利な関数


- `rep()` 関数は同じ値を指定の回数出力する。

```{r}
rep("A", times = 10)
```

- よって、`rep()` 関数は要素が等しい数列の作成に便利である。

```{r}
rep(x, times = 3)
```

---
## ここまでのまとめ

- 4 種類のことなる手法をみてきた。
    1. `c()`
    2. `:`
    3. `seq()`
    4. `rep()`

 - 一緒に使われることも多い。

```{r}
c(x, rep(seq(1, 9, 2), 3), c(1, 2, 3), 42, 2:4)
```

---
## ベクトルの長さ

- ベクトルの長さは `length()` 関数で取得できる。

```{r}
length(x)
length(y)
```

---
## 要素

- 四角かっこ `[]` をつけると、ベクトルの要素を取得できる。
- `x[1]` は `x` の第一要素を返す。Rにおいては添字が1からはじまることに注意！

```{r}
x
x[1]
x[3]
```

---
## 要素続き

- 特定の要素を省いたものを取得することもできる。以下では第二要素を除いている。

```{r}
x[-2]
```

- 添字はベクトルでもよい。

```{r}
x[1:3]
x[c(1,3,4)]
```

---
## 要素続き

-論理値ベクトルを添字に用いてもよい。

```{r}
z = c(TRUE, TRUE, FALSE, TRUE, TRUE, FALSE)
z
```

```{r}
x[z]
```

---
## ベクトル化

- `R` の強みの一つは、ベクトル化された（vectorized）操作が実装されていることである。
    - この点に関する理解が足りないと、`R` は遅いと信じ込むことになる。 

- ベクトルに `log()` などの関数を作用させると、ベクトルの各要素に対して操作が施されたものが出力される。

```{r}
x = 1:10
x + 1
```

```{r}
2 * x
``` 
---
## ベクトル化続き


```{r}
2 ^ x
```

```{r}
sqrt(x)
```

```{r}
log(x)
```

---
## 論理演算子

| 演算子 | 読み方               | 例               | 出力 |
|----------|-----------------------|-----------------------|--------|
| `x < y`  | `x` は `y` より小さい   | `3 < 42`               | `r 3 < 42`   |
| `x > y`  | `x` は `y` より大きい           | `3 > 42`          | `r 3 > 42`               |
| `x <= y` | `x` は `y` 以下   | `3 <= 42`              | `r 3 <= 42`              |
| `x >= y` | `x` は `y` 以上 | `3 >= 42`              | `r 3 >= 42`              |
| `x == y` | `x` は `y` に等しい   | `3 == 42`              | `r 3 == 42`              |
| `x != y` | `x` は `y` に等しくない | `3 != 42`      | `r 3 != 42`              |
| `!x`     |  `x`  でない      | `!(3 > 42)`            | `r !(3 > 42)`            |
| `x`&#124;`y`  | `x` または `y`  |  `(3 > 42)`&#124;`TRUE`      | `r (3 > 42) | TRUE`  |
| `x & y`  | `x` かつ `y`               | `(3 < 4) & (42 > 13)` | `r (3 < 4) & (42 > 13)` |


---
## 論理演算子の例

- 論理演算子はベクトル化されている。

```{r}
x = c(1, 3, 5, 7, 8, 9)
x > 3
x < 3
x == 3
x != 3
```

---
## 論理演算子の例

```{r}
x == 3 & x != 3
x == 3 | x != 3
```

---
## 論理演算子を用いた要素取得

- これはベクトルの要素の取得（切り出し）に大変便利である。

```{r}
x[x > 3]
x[x != 3]
```

---
## ちょっと練習

1. 大きさが `x` と等しいベクトル $z = (1,2,1,2,1,2)$ を作成せよ。
2. `z` のある要素と等しい `x` の要素を取り出せ。


---
class: title-slide-section, center, middle
name: logistics
# 行列

---
## 行列の操作

- `R` は**行列**の計算もできる。
  - 行列では、同じデータ型をもつ要素が行（row）と列（column）に格納されている。
- `matrix()` 関数で作成できる。

```{r}
x = 1:9
X = matrix(x, nrow = 3, ncol = 3)
X
```

- ここではふたつの変数を用いている。
    - 小文字の `x` はベクトル
    - 大文字の `X` は行列
    
---
## 行列の操作

- デフォルトでは `matrix()` は列に沿ってベクトルの要素を並べかえるので、行に沿って並べかえたければ `byrow = TRUE` とする。

```{r}
Y = matrix(x, nrow = 3, ncol = 3, byrow = TRUE)
Y
```

- 全ての要素が等しい行列は次のように作成できる。

```{r}
Z = matrix(0, 2, 4)
Z
```

---
## 行列の操作

- 行列の要素も `[]` で取得できる。
  - 行列は二次元なので、添字もふたつ指定しなければならない。
  
- `X` の1 行 2 列目の要素 $X_{12}$ を取得するなら次のようにする。

```{r}
X
X[1, 2]
```

---
## 行列の操作

- 行・列のみを指定して切り出すこともできる。

```{r}
X[1, ]
X[, 2]
```

---
## 行列の操作

- ベクトルを行で結合（`rbind()`）したり、列で結合（`cbind()`）したりして、行列を作成することもできる。

```{r}
x = 1:9
rev(x)
rep(1, 9)
```

```{r}
rbind(x, rev(x), rep(1, 9))
```

---
## 行列の操作

- これらの関数を用いるときは、行名・列名をつけることができる。

```{r}
cbind(col_1 = x, col_2 = rev(x), col_3 = rep(1, 9))
```

---
## 行列計算

- 行列計算の実例を示す。

```{r}
x = 1:9
y = 9:1
X = matrix(x, 3, 3)
Y = matrix(y, 3, 3)
X
Y
```

---
## 足し算・引き算

```{r}
X + Y
```

```{r}
X - Y
```

---
## 要素ごとの掛け算・割り算

```{r}
X * Y
```

```{r}
X / Y
```

- `X * Y` は**行列の積ではない。**行列の要素ごとの積 $X \odot Y$ である。
- `X / Y` も同様に、要素ごとの商である。

---
## 行列の積

- 行列の積 $XY$ には `%*%` を使う。

```{r}
X %*% Y
```

- 転置行列 $X^{\top}$ を得るには `t()` を使う。

```{r}
t(X)
```

---
## 逆行列

- `solve()` は、行列 $Z$ が正則ならば逆行列 $Z^{-1}$ を返す。

```{r}
Z = matrix(c(9, 2, -3, 2, 4, -2, -3, -2, 16), 3, byrow = TRUE)
Z
solve(Z)
```

---
## 逆行列の確認

- 逆行列がちゃんと計算されているか確かめるために、 $Z^{-1}Z$ を計算してみよう。もし正しければ、単位行列が出力されるはずである。

```{r}
solve(Z) %*% Z
diag(3)
all.equal(solve(Z) %*% Z, diag(3))
```

---
## ちょっと練習

- 次の連立方程式（同時方程式）を行列を用いて計算せよ。
$$
\begin{aligned}
2x_1+3x_2	&=& 10 \\
5x_1+x_2	&=& 20
\end{aligned}
$$
- ヒント：上の方程式を、$2 \times 2$ の行列 $A$ を用いて $Ax = y$ の形に書き直してみよう。

---
## 行列の特徴

- 行列の次元や情報を取得するための関数が用意されている。

```{r}
X = matrix(1:6, 2, 3)
X
dim(X)
rowSums(X)
```

---
## 行列の特徴

```{r}
colSums(X)
rowMeans(X)
colMeans(X)
```

---
## 対角要素・単位行列

- `diag()` 関数に行列を入力すると、対角要素が出力される。

```{r}
diag(Z)
```

- 数列を与えると対角行列が出力される。

```{r}
diag(1:5)
```

---
## 単位行列

- 数値を与えると、その値に応じた次元の単位行列が出力される。

```{r}
diag(5)
```

---
class: title-slide-section, center, middle
name: logistics
# リスト

---
## リスト

- リストは異質な型の要素を許す一次元のデータ構造である。
    - 添字はひとつ
    - 要素の型は問わない

```{r}
list(42, "Hello", TRUE)
```

---
## 例

```{r}
ex_list = list(
  a = c(1, 2, 3, 4),
  b = TRUE,
  c = "Hello!",
  d = function(arg = 42) {print("Hello World!")},
  e = diag(5)
)
```

---
## リストの要素取得

- リストの要素はふたつの方法で取得できる。 
    1. `$` 演算子
    2. `[]`


```{r}
ex_list$e
```

```{r}
ex_list[1:2]
```

---
## リストの要素取得

```{r}
ex_list[c("e", "a")]
```

```{r}
ex_list["e"]
```

```{r}
ex_list$d
```

---
## データフレーム

- 別途説明する。

---
class: title-slide-section, center, middle
name: logistics
# 制御構造

---
## if 文

- `if` 文は次のような構造をしている。

```{r, eval = FALSE}
if (...) {
  some R code
} else {
  more R code
}
```

---
## 例：`x` と `y` の大小比較

```{r}
x <- 1
y <- 3
if (x > y) {
  z <- x * y
  print("x is larger than y")
} else {
  z <- x + 5 * y
  print("x is less than or equal to y")
}

z
```

---
## `ifelse` 関数

- `R` には `ifelse()` 関数が用意されている。
    - 与えられた条件に基づいて値を出力する。

```{r}
ifelse(4 > 3, 1, 0)
```

- `ifelse()` はベクトルに適用できるのがよい。

```{r}
fib <- c(1, 1, 2, 3, 5, 8, 13, 21)
ifelse(fib > 6, "Foo", "Bar")
```

---
## for 文

- `for` 文は、一定の回数だけ同じ手続きを繰り返す。

```{r}
x <- 11:15
for (i in 1:5) {
  x[i] <- x[i] * 2
}

x
```

---
## for 文

- `for` 文はプログラミング言語で一般に利用される制御構造である。
- `R` ではベクトル化演算が実装されているので、できる限り使わない方がよい。
    - `R` の `for` 文は遅いということで悪名高い。

```{r}
x <- 11:15
x <- x * 2
x
```

---
class: title-slide-section, center, middle
name: logistics
# 関数

---
## 関数

- 関数を使うには、 
    - 関数名を入力し、
    - かっこの中に引数を入力し、
    - かっこを閉じる。
    
- **引数（argument）**とは関数が用いる変数のことである。

```{r, eval = FALSE}
# これはデモ
# !NOT RUN
function_name(arg1 = 10, arg2 = 20)
```

- 自前の関数を作成することもできる。

---
## 例

- 例：変数の標準化
$$
\frac{x - \bar{x}}{s}
$$
- 関数を作成するときは、
    1. 関数名を与える。短く、かつわかりやすい名前をつけること。
    2. `function()` を使って引数を指定する。
    3. `{}` のなかに関数が行う操作を記述する。

---
## 関数の定義

```{r}
standardize <- function(x) {
  m <- mean(x)
  std <- sd(x)
  result <- (x - m) / std
  return(result)
}
```

- 関数名は `standardize` 
- 引数は `x` 
- `return()` で出力

---
## 関数を使ってみる

- 関数をテストしてみよう。
- $\mathcal{N}(2, 25)$ から 10 標本を取り出す。

```{r}
test_sample <- rnorm(n = 10, mean = 2, sd = 5)
test_sample
standardize(x = test_sample)
```

---
## デフォルトの引数


- デフォルトの引数を指定することもできる。

```{r}
power_of_num = function(num, power = 2) {
  num ^ power
}
```

---
## 例
- 関数の挙動をみるために、さまざまなやり方を試してみる。全て $10^2 = 100$ を計算する。

```{r}
power_of_num(10)
power_of_num(10, 2)
power_of_num(num = 10, power = 2)
power_of_num(power = 2, num = 10)

```

---
## 注意：引数の順序

- 引数名を指定しない場合、引数の順序が問題になってくる。以下では、 $10^2$ ではなく $2^{10}$ が計算される。

```{r}
power_of_num(2, 10)
```

- デフォルトの値が定まっていない引数に入力を与えない場合、エラーになる。

```{r, eval = FALSE}
power_of_num(power = 5)
```

---
## 標本分散

- 標本分散を二通りで計算する関数を作成し、デフォルトの引数の挙動について詳しくみてみよう。

- デフォルトでは、不偏分散 $\sigma^2$ を計算する。これを $s^2$ とする。
$$
s^2 = \frac{1}{n - 1}\sum_{i=1}^{n}(x - \bar{x})^2
$$
- 最尤法に基づく、不偏ではない標本分散の推定値 $\hat{\sigma}^2$ も計算する。
$$
\hat{\sigma}^2 = \frac{1}{n}\sum_{i=1}^{n}(x - \bar{x})^2
$$

---
## 関数の定義

```{r}
get_var = function(x, unbiased = TRUE) {

  if (unbiased == TRUE){
    n = length(x) - 1
  } else if (unbiased == FALSE){
    n = length(x) 
   }

  (1 / n) * sum((x - mean(x)) ^ 2)
}
```

---
## 結果１

```{r}
get_var(test_sample)
get_var(test_sample, unbiased = TRUE)
var(test_sample)
```

---
## 結果2

- 作成した関数が期待通りの挙動をし、`R` に実装されている `var()` 関数と値が一致した。次に、不偏でない $\sigma^2$ の推定値を計算する。

```{r}
get_var(test_sample, unbiased = FALSE)
```


---
class: title-slide-section, center, middle
name: logistics
# Data frame



---
## Introduction 

- A **data frame** is the most common way that we store and interact with data in this course.

```{r}
example_data = data.frame(x = c(1, 3, 5, 7, 9, 1, 3, 5, 7, 9),
                          y = c(rep("Hello", 9), "Goodbye"),
                          z = rep(c(TRUE, FALSE), 5))
```

- A data frame is a **list** of vectors.
    - Each vector must contain the same data type
    - The difference vectors can store different data types.

---
## 中身を見る

```{r}
example_data
```

---
## データフレームをCSVファイルで保存する

- `write.csv` save (or export) the dataframe in `.csv` format.

```{r, echo=TRUE}
write.csv(example_data, "example-data.csv", row.names = FALSE)
```


---
## Load csv file

- We can also import data from various file types in into `R`, as well as use data stored in packages.
- Read `csv` file into R. 
    - `read.csv()` function as default
    - `read_csv()` function from the `readr` package. This is faster for larger data.

```{r, message = FALSE, warning = FALSE}
library(readr)
example_data_from_csv = read.csv("example-data.csv")
```


---
## Note:

- Note: This particular line of code assumes that the file `example_data.csv` exists in your current working directory.
- The current working directory is the folder that you are working with. To see this, you type 
```{r}
getwd()
```
- If you want to set the working directory, use `setwd()` function
```{r, eval = FALSE}
setwd(dir = "directory path" )
```

<!-- >

```{r}
example_data_from_csv
```

A tibble is simply a data frame that prints with sanity. Notice in the output above that we are given additional information such as dimension and variable type.

The `as_tibble()` function can be used to coerce a regular data frame to a tibble.

```{r}
library(tibble)
example_data = as_tibble(example_data)
example_data
```
< -->


---
## Examine dataframe

- Inside the `ggplot2` package is a dataset called `mpg`. By loading the package using the `library()` function, we can now access `mpg`.

```{r, message = FALSE, warning = FALSE}
library(ggplot2)
```

---
## Examine dataframe

- Three things we would generally like to do with data:
    - Look at the raw data.
    - Understand the data. (Where did it come from? What are the variables? Etc.)
    - Visualize the data.
- To look at the data, we have two useful commands: `head()` and `str()`
```{r}
head(mpg, n = 5)
```

---
## `str()` function

- The function `str()` will display the "structure" of the data frame.
    - It will display the number of **observations** and **variables**, list the variables, give the type of each variable, and show some elements of each variable. 
    - This information can also be found in the "Environment" window in RStudio.
```{r}
str(mpg)
```


---
## `names()` function

-  `names()` function to obtain names of the variables in the dataset
```{r}
names(mpg)
```

- To access one of the variables **as a vector**, we use the `$` operator.
```{r}
mpg$year
mpg$hwy
```

---
## Dimension of dataframe
- We can use the `dim()`, `nrow()` and `ncol()` functions to obtain information about the dimension of the data frame.

```{r}
dim(mpg)
nrow(mpg)
ncol(mpg)
```

---
## Subsetting data

- Subsetting data frames can work much like subsetting matrices using square brackets, `[,]`. 
- Here, we find fuel efficient vehicles earning over 35 miles per gallon and only display `manufacturer`, `model` and `year`.

```{r}
mpg[mpg$hwy > 35, c("manufacturer", "model", "year")]
```

---
## Subseting data (cont.d)
- An alternative would be to use the `subset()` function, which has a much more readable syntax.

```{r, eval = FALSE}
subset(mpg, 
       subset = hwy > 35, 
       select = c("manufacturer", "model", "year"))
```

---
## dplyr package

- Lastly, we could use the `filter` and `select` functions from the `dplyr` package which introduces the `%>%` operator from the `magrittr` package. 
```{r, eval = FALSE}
library(dplyr)
mpg %>% 
  filter(hwy > 35) %>% 
  select(manufacturer, model, year)
```

