R을 이용한 통계 프로그래밍 기초 2장

R을 이용한 통계 프로그래밍 기초

<프로그램>

# R을 이용한 통계 프로그래밍 기초
# 2장

# 2.2

# 2.2.1 단순 계산

2+3
2^3
1/2
3-2*1+4

# 2.2.2 함수를 이용한 계산

sqrt(2)
sin(pi)
exp(1)
log(10,base=10)
log(10,base=2)
log(10,base=3)
log(10)
abs(-3)
abs(3)
factorial(5)
choose(5,2)

# 2.2.3 경고와 오류

squareroot(3)
sqrt{3}
sqrt(-3)
a=c(); a

# 2.3 할당

x.const_1 = 3
x.const_1
x = 3
x + 4
e = exp(1)
e^2
x = 3
x
y = 5
print(y)
memory.size(max = TRUE)

# 2.4 c()를 이용하여 데이터 벡터 만들기
k_score = c(96,80,76,96,88,75,78,89,92,70)
k_score
k_score2 = c(67,83,96,90,85,75,82,89,92,75)
k_score2
score = c(k_score, k_score2)
score
length(score)
mode(score)

# 2.4.1 데이터의 형태

# 문자형
y = c(1,5,7)
y
mode(y)

# 문자형
family = c("kim", "lee", "chulsu", "sunhee")
family
mode(family)
names(family) = c("father","mother","son","daughter")
family
names(family)
family['father']
family[1]

x = c("kim",2,3)
x
mode(x)

# 논리형
c(T,F,F,F,T,T,F)
x = -3:3
x
w = x < 2 # x의 원소 중 2 미만이면 T, 아니면 F
w
mode(w)
sum(w) # T는 1로, F는 0으로 변환하여 계산

# 2.4.2 데이터의 형태 변환
fact = c(1,2,3) # 데이터
fact
mode(fact)

fact1 = as.factor(fact) # 범주형 factor로 변환
fact1
mode(fact1)

f.log = as.logical(fact) # 논리형 데이터로 변환
f.log
mode(f.log)

exp.fact = factor(c("exp1","exp2")) # 범주형 데이터
exp.fact
mode(exp.fact)
fact2 = as.numeric(exp.fact) # 숫자형 데이터로 변환
fact2
mode(fact2)

# 2.5 데이터 벡터에 함수 적용하기

# 2.5.1 반올림

a = c(-2.456, 3.6789, 5.23445676)
a

ceiling(a) # 정수형으로 올림(주어진 값의 초과하는 최소의 정수)

floor(a) # 정수형으로 버림(주어진 값의 미만하는 최대의 정수)

trunc(a) # 주어진 값에서 0에 가까운 정수

round(a) # 반올림

round(a, digits = 2) # 소수 둘째자리로 반올림

# 2.5.2 기초 통계량

k_score = c(96, 80, 76, 96, 88, 75, 78, 89, 92, 70)
k_score

sum(k_score) # 합
length(k_score) # 개수
mean(k_score) # 평균
max(k_score) # 최대
min(k_score) # 최소
range(k_score) # 범위
var(k_score) # 분산
sd(k_socre) # 표준편차
median(k_score) # 중앙값
rank(k_score) # 동점은 중간값으로 처리

# 2.5.3 apply() : 행렬의 행과 열에 원하는 함수를 적용하는 함수

x = cbind(x1=3, x2=c(4:1, 2:8)) # 행렬 생성
is.matrix(x) # 행렬인지 확인
dimnames(x) # 행과 열의 이름 확인, 행의 이름이 없음
dimnames(x)[[1]] = letters[1:nrow(x)] # 행에 알파벳 이름 붙이기, letters는 알파벳을 저장한 R 의 상수
apply(x, 2, mean) # 열의 평균
apply(x, 2, sum) # 열의 합

# 2.5.4 aggregate() : 그룹별 또는 요인별 함수를 이용한 통계량 구하기
library(MASS) # R의 내장 자료를 이용하기 위하여
data(cabbages) # R의 내장 자료 불러오기
cabbages
attributes(cabbages) # 속성 확인
is.data.frame(cabbages) # 자료의 종류가 데이타 프레임인지 확인
attributes(cabbages$Cult) # Cult의 속성 확인, factor
attributes(cabbages$Date) # Date의 속성 확인, factor
is.factor(cabbages$Date)
attach(cabbages)
aggregate(HeadWt, list(Cult, Date), FUN = "mean") #Cult, Date 별 HeadWt의 평균

# 2.5.5 필요한 데이터만 선택하기
cabbages1 <- cabbages[Date == "d16",] # Date가 d16인 자료 뽑기
cabbages1
cabbages2 <- cabbages[VitC >= 70,] # VitC가 70가 이상인 자료 뽑기
cabbages2
cabbages3 <- cabbages[cabbages$Date == "d16" & cabbages$VitC >= 60,] # Date가 d16이고, VitC가 60이상인 자료 뽑기
cabbages3

# 2.5.6 순서 함수
id <- c(1,2,3,4,5) # vector 생성
a <- c(4,9,7,2,8) # vector 생성
da <- cbind(id, a) # matrix 생성
da
attributes(da)
is.matrix(da) # 행렬인지 확인
a_s <- sort(a) # 순서대로 정렬
a_s
da[order(da[,"a"]),] # da 행렬의 a열의 오름차순으로 정렬
da[order(-da[,"a"]),] # da 행렬의 a열의 내림차순으로 정렬

x <- c(11,24,24,30,30,30)
rank(x) # x의 순위
order(x) # x의 순서

# 2.6 구조적인 데이터 만들기

1:10 # 1에서 10까지의 벡터
seq(1,10) # 1에서 10까지의 벡터
rev(1:10) # 10에서 1까지의 벡터
10:1 # 10에서 1까지의 벡터
seq(10,1) # 10에서 1까지의 벡터
seq(1,10,by = 2) # 1에서 10까지 2씩 증가
seq(from = 5, to = 22, by = 2) # 5에서 22까지 2씩 증가
rep(1,10) # 1을 10번 반복
rep(1:3,3) # 1에서 3까지를 3번 반복
rep(c(2,4,5),4) # 2,4,5를 4번 반복하는 벡터

# 2.7 데이터 벡터 다루기

x <- c(100, 120, 130, 124, 150, 167, 170, 163, 160, 155, 145, 157)
x[1] # x 벡터의 1번째 값
x[9] # x 벡터의 9번째 값
x[1:3] # x 벡터 1에서 3번째 값
x[c(6,7,9)] # x 벡터의 6, 7, 9번째 값
x[-1] # x 벡터의 1번째 값을 제외
x[-c(1,12)] # x 벡터의 1, 12번째 값을 제외
x[x != 150] # x 벡터의 값 중 150이 아닌 것
x[x >= 150] # x 벡터의 값 중 150 이상인 것

# 2.8 벡터와 행렬 표현과 연산

a = c(1, 3, 5) # 벡터 생성
a

b = matrix(1:6, nrow = 2) # 행렬 생성, 행이 2
b

d = matrix(1:6, ncol = 2) # 행렬 생성, 열이 2
d

# 2.8.1 기본 연산
x = 1:5 # 벡터 생성
y = 1:5 * -1 # 벡터 생성
x + y # 벡터 각 원소의 합
x * y # 벡터 각 원소의 곱
t(x) %*% y # t' * y로 행렬 생성
x %*% t(x) # x * x'로 행렬 생성
c(x, y) # x 벡터와 y 벡터를 결합하여 벡터 생성
rbind(x, y) # x 벡터와 y 벡터를 행으로 결합하여 행렬 생성
t1 = cbind(x, y) # x 벡터와 y 벡터를 열로 결합하여 행렬 생성
t1
t(t1) # 전치 행렬(transpose)
t(t1) %*% t1 # t1' * t1
crossprod(t1) # t1' * t1
dim(t1) # 행렬의 차원, 즉 행과 열의 수

# 2.8.2 역행렬(inverse)

s = matrix(c(34.74, 15.66, 15.66, 378.6), nrow = 2)
s
det(s) # 행렬의 determinant
solve(s) # 행렬의 역행렬

library(MASS)
ginv(s) # 행렬의 무어-펜로드 일반화 역행렬, 행렬식이 0이 아닌 경우 solve와 동일한 결과

# 2.8.3 고유값과 고유벡터
eigen(s) # 고유값(eigenvalue)과 고유벡터(eigenvector) 구하기
ei = eigen(s) # 결과를 ei에 저장, ei는 list
ei[[1]] # ei의 첫번째 데이터 집합, list에서는 [[]]이용
ei$values # ei의 values 데이터 집합
ei[[1]][1] # 첫번째 고유값
ei$values[1] # 첫번째 고유값
ei[[2]] # ei의 두번째 데이터 집합
ei$vectors # ei의 vector 데이터 집합
ei[[2]][2,] # 두번째 고유벡터
ei$vectors[2,] # 두번째 고유벡터

# 2.9 배열
g <- array(1:24, c(4,3,2)) # 배열 생성
g
attributes(g) # 속성
mode(g) # 자료의 종류
is.array(g) # 배열인지 확인
dim(g) # dimension

g[1,,]

# 2.10 반복문

# 2.10.1 for()를 이용한 루핑

start <- 100 # 100에서 200까지 구하기
end <- 200
isum <- 0
for(i in start:end) {
isum <- isum + i
}
isum

for ( i in 5:8) { # 5^2, ..., 8^2 구하기
print(i^2)
}

# 2.10.2 while()을 이용한 루핑

# 1에서 n까지의 합, 합이 100을 넘은 최소값

n = 0
sum.sofar = 0
while(sum.sofar <= 100) {
n = n + 1
sum.sofar = sum.sofar + n
}
n
sum.sofar

# 2.10.3 repeat()를 이용한 루핑

# 1에서 n까지의 합, 합이 100을 넘은 최소값

n = 0
sum.sofar = 0
repeat{
n = n + 1
sum.sofar = sum.sofar + n
if (sum.sofar > 100) break
}
n
sum.sofar

# 2.11 조건문 (if else)

# x의 원소가 양수이면 pos에 1, 아니면 0저장.

x = c(1, -2, -3, 4, 5)
pos = rep(0, 5)
for (i in 1:5) {
if (x[i] > 0) pos[i] = 1
else pos[i] = 0
}
pos

# 2.12 결측값

x = c(1, 6, 2, NA) # 결측값의 입력
is.na(x) # 결측값의 위치
x[x > 2] # x의 원소 중 2를 초과한 값 뽑기. NA도 포함됨
mean(x) # 결측값 때문에 평균계산 못함
mean(x, na.rm = TRUE) # 결측값 제외하고 평균 구하기
xx = na.omit(x) # 결측값을 제외한 벡터 만들기

rank(x) # 순위
rank(x, na.last = TRUE) # 결측값 순위 마지막
rank(x, na.last = FALSE) # 결측값 순위 첫째

# 2.13 데이터 프레임

# 각 열마다 서로 다른 자료형(mode)을 가질 수 있는 구조 : list와 같음
# 그러나 테이블 형태 : list와 다른 점

data(OrchardSprays)
OrchardSprays
is.data.frame(OrchardSprays) # 데이타 프레임인지 확인
mode(OrchardSprays) # mode는 list로 나옴
names(OrchardSprays) # 변수명 확인
row.names(OrchardSprays) # 행의 이름 확인, 특별한 이름이 없으므로 숫자가 나옴
dim(OrchardSprays) # 자료의 수와 변수의 수
nrow(OrchardSprays) # 자료의 수
ncol(OrchardSprays) # 변수의 수

# 2.14 내장 데이터 셋 읽기

data() # 내장 데이터 셋의 종류 확인
data(Orange) # Orange 데이터 셋 불러오기
dim(Orange) # 자료의 수와 변수의 수 확인

# 2.15 데이터 파일 읽기와 결과 파일 만들기

# 2.15.1 txt 파일 데이터를 읽을 경우

zzz = read.table("data1.txt", header = TRUE) # 텍스트 자료를 데이타 프레임으로 불러오기
zzz
attributes(zzz) # 변수이름, 데이터 프레임, 행이름 확인
zzz$x # 변수 x 확인
zzz$x[2] # 변수 x의 두번째 자료 확인
zzz[[3]] # 세번째 변수 확인

# 2.15.2 Excel 파일 데이터를 읽을 경우

zz = read.csv("data1.csv", header = TRUE, sep = ",")
zz

# 2.15.3 결과 파일 만들기

cat("data set example", "\n",
"x = ", zzz$x, "\n",
"y = ", zzz$y,
file = "out1.txt") # cat 함수 이용

write.table(zzz, file = "out2.txt",row.names = FALSE) # write.table 함수 이용

# (1) txt로 저장

mydef = c(1,2,3)
write.table(mydef, "out3.txt", sep=",", row.names = FALSE)

# (2) csv로 저장
my1 = c(1,2,3)
my2 = c(4,5,6)
write.table(cbind(my1, my2), "out4.txt", sep = ",", row.names = FALSE)

# 2.16 데이터셋 합치기

authors <- data.frame(
surname = I(c("Tukey", "Venables", "Tierney", "Ripley", "McNeil")),
nationality = c("US", "Australia","US","UK","Australia")
)
authors
books <- data.frame(
name = I(c("Tukey", "Venables", "Tierney", "Ripley", "McNeil")),
year = c(1976,1995,1996,1998,2000)
)
books

# 두 데이터 프레임을 surname, name을 기준으로 merge하기
d = merge(authors, books, by.x = "surname", by.y = "name")
d

authors2 <- data.frame(
surname = I(c("Tukey", "Venables", "Tierney", "Ripley", "McNeil", "Park")),
nationality = c("US", "Australia","US","UK","Australia","Korea")
)
authors2

books2 <- data.frame(
name = I(c("Tukey", "Venables", "Tierney", "Ripley", "McNeil", "Kim")),
year = c(1976,1995,1996,1998,2000,2008)
)
d2 = merge(authors2, books2, by.x = "surname", by.y = "name") # all = TRUE를 쓰지 않은 merge
d2 # 결측값이 있는 행을 제외

d3 = merge(authors2, books2, by.x = "surname", by.y = "name", all = TRUE) # all = TRUE를 사용한 merge
d3 # 결측값이 있는 행도 표시

# 2.17 객체 관리

# 2.17.1 객체 리스트

ls() # 작업공간에 저장되어 있는 객체 목록 표시

# 2.17.2 데이터 객체 지우기

<실행 결과>

R version 2.8.0 (2008-10-20)
Copyright (C) 2008 The R Foundation for Statistical Computing
ISBN 3-900051-07-0

R은 free 소프트웨어이고, [완전하게 무보증]입니다.
일정한 조건에 따르면, 자유롭게 이것을 재배포할수가 있습니다.
배포 조건의 상세한것에 대해서는 'license()' 또는 'licence()' 라고 입력해주십시오

R는 많은 공헌자에의한 공동 프로젝트입니다
더 자세한것에 대해서는 'contributors()'라고 입력해 주십시오.
또는, R나 R의 패키지를 출판물로 인용할때의 형식에 대해서는
'citation()'라고 입력해주십시오
'demo()'라고 입력하면, demos를 볼수가 있습니다.
'help()'라고 한다면, on-line help가 나옵니다.
'help.start()'로 HTML 브라우저에 의한 help가 보여집니다
'q()'라고 입력하면 R를 종료합니다
> # R을 이용한 통계 프로그래밍 기초
> # 2장
>
> # 2.2
>
> # 2.2.1 단순 계산
>
> 2+3
[1] 5
> 2^3
[1] 8
> 1/2
[1] 0.5
> 3-2*1+4
[1] 5
>
> # 2.2.2 함수를 이용한 계산
>
> sqrt(2)
[1] 1.414214
> sin(pi)
[1] 1.224606e-16
> exp(1)
[1] 2.718282
> log(10,base=10)
[1] 1
> log(10,base=2)
[1] 3.321928
> log(10,base=3)
[1] 2.095903
> log(10)
[1] 2.302585
> abs(-3)
[1] 3
> abs(3)
[1] 3
> factorial(5)
[1] 120
> choose(5,2)
[1] 10
>
> # 2.2.3 경고와 오류
>
> squareroot(3)
에러:함수 "squareroot"를 검색해낼수가 없었습니다
> sqrt{3}
에러:unexpected '{' in "sqrt{"
> sqrt(-3)
[1] NaN
Warning message:
In sqrt(-3) : NANs가 작성되었습니다
> a=c(); a
NULL
>
> # 2.3 할당
>
> x.const_1 = 3
> x.const_1
[1] 3
> x = 3
> x + 4
[1] 7
> e = exp(1)
> e^2
[1] 7.389056
> x = 3
> x
[1] 3
> y = 5
> print(y)
[1] 5
> memory.size(max = TRUE)
[1] 12.3125
>
> # 2.4 c()를 이용하여 데이터 벡터 만들기
> k_score = c(96,80,76,96,88,75,78,89,92,70)
> k_score
[1] 96 80 76 96 88 75 78 89 92 70
> k_score2 = c(67,83,96,90,85,75,82,89,92,75)
> k_score2
[1] 67 83 96 90 85 75 82 89 92 75
> score = c(k_score, k_score2)
> score
[1] 96 80 76 96 88 75 78 89 92 70 67 83 96 90 85 75 82 89 92 75
> length(score)
[1] 20
> mode(score)
[1] "numeric"
>
>
> # 2.4.1 데이터의 형태
>
> # 문자형
> y = c(1,5,7)
> y
[1] 1 5 7
> mode(y)
[1] "numeric"
>
> # 문자형
> family = c("kim", "lee", "chulsu", "sunhee")
> family
[1] "kim" "lee" "chulsu" "sunhee"
> mode(family)
[1] "character"
> names(family) = c("father","mother","son","daughter")
> family
father mother son daughter
"kim" "lee" "chulsu" "sunhee"
> names(family)
[1] "father" "mother" "son" "daughter"
> family['father']
father
"kim"
> family[1]
father
"kim"
>
> x = c("kim",2,3)
> x
[1] "kim" "2" "3"
> mode(x)
[1] "character"
>
> # 논리형
> c(T,F,F,F,T,T,F)
[1] TRUE FALSE FALSE FALSE TRUE TRUE FALSE
> x = -3:3
> x
[1] -3 -2 -1 0 1 2 3
> w = x < 2 # x의 원소 중 2 미만이면 T, 아니면 F
> w
[1] TRUE TRUE TRUE TRUE TRUE FALSE FALSE
> mode(w)
[1] "logical"
> sum(w) # T는 1로, F는 0으로 변환하여 계산
[1] 5
>
> # 2.4.2 데이터의 형태 변환
> fact = c(1,2,3) # 데이터
> fact
[1] 1 2 3
> mode(fact)
[1] "numeric"
>
> fact1 = as.factor(fact) # 범주형 factor로 변환
> fact1
[1] 1 2 3
Levels: 1 2 3
> mode(fact1)
[1] "numeric"
>
> f.log = as.logical(fact) # 논리형 데이터로 변환
> f.log
[1] TRUE TRUE TRUE
> mode(f.log)
[1] "logical"
>
> exp.fact = factor(c("exp1","exp2")) # 범주형 데이터
> exp.fact
[1] exp1 exp2
Levels: exp1 exp2
> mode(exp.fact)
[1] "numeric"
> fact2 = as.numeric(exp.fact) # 숫자형 데이터로 변환
> fact2
[1] 1 2
> mode(fact2)
[1] "numeric"
>
> # 2.5 데이터 벡터에 함수 적용하기
>
> # 2.5.1 반올림
>
> a = c(-2.456, 3.6789, 5.23445676)
> a
[1] -2.456000 3.678900 5.234457
>
> ceiling(a) # 정수형으로 올림(주어진 값의 초과하는 최소의 정수)
[1] -2 4 6
>
> floor(a) # 정수형으로 버림(주어진 값의 미만하는 최대의 정수)
[1] -3 3 5
>
> trunc(a) # 주어진 값에서 0에 가까운 정수
[1] -2 3 5
>
> round(a) # 반올림
[1] -2 4 5
>
> round(a, digits = 2) # 소수 둘째자리로 반올림
[1] -2.46 3.68 5.23
>
> # 2.5.2 기초 통계량
>
> k_score = c(96, 80, 76, 96, 88, 75, 78, 89, 92, 70)
> k_score
[1] 96 80 76 96 88 75 78 89 92 70
>
> sum(k_score) # 합
[1] 840
> length(k_score) # 개수
[1] 10
> mean(k_score) # 평균
[1] 84
> max(k_score) # 최대
[1] 96
> min(k_score) # 최소
[1] 70
> range(k_score) # 범위
[1] 70 96
> var(k_score) # 분산
[1] 87.33333
> sd(k_socre) # 표준편차
이하에 에러sd(k_socre) : object "k_socre" not found
> median(k_score) # 중앙값
[1] 84
> rank(k_score) # 동점은 중간값으로 처리
[1] 9.5 5.0 3.0 9.5 6.0 2.0 4.0 7.0 8.0 1.0
>
> # 2.5.3 apply() : 행렬의 행과 열에 원하는 함수를 적용하는 함수
>
> x = cbind(x1=3, x2=c(4:1, 2:8)) # 행렬 생성
> is.matrix(x) # 행렬인지 확인
[1] TRUE
> dimnames(x) # 행과 열의 이름 확인, 행의 이름이 없음
[[1]]
NULL

[[2]]
[1] "x1" "x2"

> dimnames(x)[[1]] = letters[1:nrow(x)] # 행에 알파벳 이름 붙이기, letters는 알파벳을 저장한 R 의 상수
> apply(x, 2, mean) # 열의 평균
x1 x2
3.000000 4.090909
> apply(x, 2, sum) # 열의 합
x1 x2
33 45
>
>
> # 2.5.4 aggregate() : 그룹별 또는 요인별 함수를 이용한 통계량 구하기
> library(MASS) # R의 내장 자료를 이용하기 위하여
> data(cabbages) # R의 내장 자료 불러오기
> cabbages
Cult Date HeadWt VitC
1 c39 d16 2.5 51
2 c39 d16 2.2 55
3 c39 d16 3.1 45
4 c39 d16 4.3 42
5 c39 d16 2.5 53
6 c39 d16 4.3 50
7 c39 d16 3.8 50
8 c39 d16 4.3 52
9 c39 d16 1.7 56
10 c39 d16 3.1 49
11 c39 d20 3.0 65
12 c39 d20 2.8 52
13 c39 d20 2.8 41
14 c39 d20 2.7 51
15 c39 d20 2.6 41
16 c39 d20 2.8 45
17 c39 d20 2.6 51
18 c39 d20 2.6 45
19 c39 d20 2.6 61
20 c39 d20 3.5 42
21 c39 d21 2.2 54
22 c39 d21 1.8 59
23 c39 d21 1.6 66
24 c39 d21 2.1 54
25 c39 d21 3.3 45
26 c39 d21 3.8 49
27 c39 d21 3.2 49
28 c39 d21 3.6 55
29 c39 d21 4.2 49
30 c39 d21 1.6 68
31 c52 d16 2.0 58
32 c52 d16 2.4 55
33 c52 d16 1.9 67
34 c52 d16 2.8 61
35 c52 d16 1.7 67
36 c52 d16 3.2 68
37 c52 d16 2.0 58
38 c52 d16 2.2 63
39 c52 d16 2.2 56
40 c52 d16 2.2 72
41 c52 d20 4.0 52
42 c52 d20 2.8 70
43 c52 d20 3.1 57
44 c52 d20 4.2 58
45 c52 d20 3.7 47
46 c52 d20 3.0 56
47 c52 d20 2.2 72
48 c52 d20 2.3 63
49 c52 d20 3.8 54
50 c52 d20 2.0 60
51 c52 d21 1.5 78
52 c52 d21 1.4 75
53 c52 d21 1.7 70
54 c52 d21 1.3 84
55 c52 d21 1.7 71
56 c52 d21 1.6 72
57 c52 d21 1.4 62
58 c52 d21 1.0 68
59 c52 d21 1.5 66
60 c52 d21 1.6 72
> attributes(cabbages) # 속성 확인
$names
[1] "Cult" "Date" "HeadWt" "VitC"

$class
[1] "data.frame"

$row.names
[1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
[25] 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
[49] 49 50 51 52 53 54 55 56 57 58 59 60

> is.data.frame(cabbages) # 자료의 종류가 데이타 프레임인지 확인
[1] TRUE
> attributes(cabbages$Cult) # Cult의 속성 확인, factor
$levels
[1] "c39" "c52"

$class
[1] "factor"

> attributes(cabbages$Date) # Date의 속성 확인, factor
$levels
[1] "d16" "d20" "d21"

$class
[1] "factor"

> is.factor(cabbages$Date)
[1] TRUE
> attach(cabbages)
> aggregate(HeadWt, list(Cult, Date), FUN = "mean") #Cult, Date 별 HeadWt의 평균
Group.1 Group.2 x
1 c39 d16 3.18
2 c52 d16 2.26
3 c39 d20 2.80
4 c52 d20 3.11
5 c39 d21 2.74
6 c52 d21 1.47
>
> # 2.5.5 필요한 데이터만 선택하기
> cabbages1 <- cabbages[Date == "d16",] # Date가 d16인 자료 뽑기
> cabbages1
Cult Date HeadWt VitC
1 c39 d16 2.5 51
2 c39 d16 2.2 55
3 c39 d16 3.1 45
4 c39 d16 4.3 42
5 c39 d16 2.5 53
6 c39 d16 4.3 50
7 c39 d16 3.8 50
8 c39 d16 4.3 52
9 c39 d16 1.7 56
10 c39 d16 3.1 49
31 c52 d16 2.0 58
32 c52 d16 2.4 55
33 c52 d16 1.9 67
34 c52 d16 2.8 61
35 c52 d16 1.7 67
36 c52 d16 3.2 68
37 c52 d16 2.0 58
38 c52 d16 2.2 63
39 c52 d16 2.2 56
40 c52 d16 2.2 72
> cabbages2 <- cabbages[VitC >= 70,] # VitC가 70가 이상인 자료 뽑기
> cabbages2
Cult Date HeadWt VitC
40 c52 d16 2.2 72
42 c52 d20 2.8 70
47 c52 d20 2.2 72
51 c52 d21 1.5 78
52 c52 d21 1.4 75
53 c52 d21 1.7 70
54 c52 d21 1.3 84
55 c52 d21 1.7 71
56 c52 d21 1.6 72
60 c52 d21 1.6 72
> cabbages3 <- cabbages[cabbages$Date == "d16" & cabbages$VitC >= 60,] # Date가 d16이고, VitC가 60이상인 자료 뽑기
> cabbages3
Cult Date HeadWt VitC
33 c52 d16 1.9 67
34 c52 d16 2.8 61
35 c52 d16 1.7 67
36 c52 d16 3.2 68
38 c52 d16 2.2 63
40 c52 d16 2.2 72
>
> # 2.5.6 순서 함수
> id <- c(1,2,3,4,5) # vector 생성
> a <- c(4,9,7,2,8) # vector 생성
> da <- cbind(id, a) # matrix 생성
> da
id a
[1,] 1 4
[2,] 2 9
[3,] 3 7
[4,] 4 2
[5,] 5 8
> attributes(da)
$dim
[1] 5 2

$dimnames
$dimnames[[1]]
NULL

$dimnames[[2]]
[1] "id" "a"

> is.matrix(da) # 행렬인지 확인
[1] TRUE
> a_s <- sort(a) # 순서대로 정렬
> a_s
[1] 2 4 7 8 9
> da[order(da[,"a"]),] # da 행렬의 a열의 오름차순으로 정렬
id a
[1,] 4 2
[2,] 1 4
[3,] 3 7
[4,] 5 8
[5,] 2 9
> da[order(-da[,"a"]),] # da 행렬의 a열의 내림차순으로 정렬
id a
[1,] 2 9
[2,] 5 8
[3,] 3 7
[4,] 1 4
[5,] 4 2
>
> x <- c(11,24,24,30,30,30)
> rank(x) # x의 순위
[1] 1.0 2.5 2.5 5.0 5.0 5.0
> order(x) # x의 순서
[1] 1 2 3 4 5 6
>
> # 2.6 구조적인 데이터 만들기
>
> 1:10 # 1에서 10까지의 벡터
[1] 1 2 3 4 5 6 7 8 9 10
> seq(1,10) # 1에서 10까지의 벡터
[1] 1 2 3 4 5 6 7 8 9 10
> rev(1:10) # 10에서 1까지의 벡터
[1] 10 9 8 7 6 5 4 3 2 1
> 10:1 # 10에서 1까지의 벡터
[1] 10 9 8 7 6 5 4 3 2 1
> seq(10,1) # 10에서 1까지의 벡터
[1] 10 9 8 7 6 5 4 3 2 1
> seq(1,10,by = 2) # 1에서 10까지 2씩 증가
[1] 1 3 5 7 9
> seq(from = 5, to = 22, by = 2) # 5에서 22까지 2씩 증가
[1] 5 7 9 11 13 15 17 19 21
> rep(1,10) # 1을 10번 반복
[1] 1 1 1 1 1 1 1 1 1 1
> rep(1:3,3) # 1에서 3까지를 3번 반복
[1] 1 2 3 1 2 3 1 2 3
> rep(c(2,4,5),4) # 2,4,5를 4번 반복하는 벡터
[1] 2 4 5 2 4 5 2 4 5 2 4 5
>
>
> # 2.7 데이터 벡터 다루기
>
> x <- c(100, 120, 130, 124, 150, 167, 170, 163, 160, 155, 145, 157)
> x[1] # x 벡터의 1번째 값
[1] 100
> x[9] # x 벡터의 9번째 값
[1] 160
> x[1:3] # x 벡터 1에서 3번째 값
[1] 100 120 130
> x[c(6,7,9)] # x 벡터의 6, 7, 9번째 값
[1] 167 170 160
> x[-1] # x 벡터의 1번째 값을 제외
[1] 120 130 124 150 167 170 163 160 155 145 157
> x[-c(1,12)] # x 벡터의 1, 12번째 값을 제외
[1] 120 130 124 150 167 170 163 160 155 145
> x[x != 150] # x 벡터의 값 중 150이 아닌 것
[1] 100 120 130 124 167 170 163 160 155 145 157
> x[x >= 150] # x 벡터의 값 중 150 이상인 것
[1] 150 167 170 163 160 155 157
>
> # 2.8 벡터와 행렬 표현과 연산
>
> a = c(1, 3, 5) # 벡터 생성
> a
[1] 1 3 5
>
> b = matrix(1:6, nrow = 2) # 행렬 생성, 행이 2
> b
[,1] [,2] [,3]
[1,] 1 3 5
[2,] 2 4 6
>
> d = matrix(1:6, ncol = 2) # 행렬 생성, 열이 2
> d
[,1] [,2]
[1,] 1 4
[2,] 2 5
[3,] 3 6
>
> # 2.8.1 기본 연산
> x = 1:5 # 벡터 생성
> y = 1:5 * -1 # 벡터 생성
> x + y # 벡터 각 원소의 합
[1] 0 0 0 0 0
> x * y # 벡터 각 원소의 곱
[1] -1 -4 -9 -16 -25
> t(x) %*% y # t' * y로 행렬 생성
[,1]
[1,] -55
> x %*% t(x) # x * x'로 행렬 생성
[,1] [,2] [,3] [,4] [,5]
[1,] 1 2 3 4 5
[2,] 2 4 6 8 10
[3,] 3 6 9 12 15
[4,] 4 8 12 16 20
[5,] 5 10 15 20 25
> c(x, y) # x 벡터와 y 벡터를 결합하여 벡터 생성
[1] 1 2 3 4 5 -1 -2 -3 -4 -5
> rbind(x, y) # x 벡터와 y 벡터를 행으로 결합하여 행렬 생성
[,1] [,2] [,3] [,4] [,5]
x 1 2 3 4 5
y -1 -2 -3 -4 -5
> t1 = cbind(x, y) # x 벡터와 y 벡터를 열로 결합하여 행렬 생성
> t1
x y
[1,] 1 -1
[2,] 2 -2
[3,] 3 -3
[4,] 4 -4
[5,] 5 -5
> t(t1) # 전치 행렬(transpose)
[,1] [,2] [,3] [,4] [,5]
x 1 2 3 4 5
y -1 -2 -3 -4 -5
> t(t1) %*% t1 # t1' * t1
x y
x 55 -55
y -55 55
> crossprod(t1) # t1' * t1
x y
x 55 -55
y -55 55
> dim(t1) # 행렬의 차원, 즉 행과 열의 수
[1] 5 2
>
> # 2.8.2 역행렬(inverse)
>
> s = matrix(c(34.74, 15.66, 15.66, 378.6), nrow = 2)
> s
[,1] [,2]
[1,] 34.74 15.66
[2,] 15.66 378.60
> det(s) # 행렬의 determinant
[1] 12907.33
> solve(s) # 행렬의 역행렬
[,1] [,2]
[1,] 0.029332174 -0.001213264
[2,] -0.001213264 0.002691494
>
> library(MASS)
> ginv(s) # 행렬의 무어-펜로드 일반화 역행렬, 행렬식이 0이 아닌 경우 solve와 동일한 결과
[,1] [,2]
[1,] 0.029332174 -0.001213264
[2,] -0.001213264 0.002691494
>
> # 2.8.3 고유값과 고유벡터
> eigen(s) # 고유값(eigenvalue)과 고유벡터(eigenvector) 구하기
$values
[1] 379.31171 34.02829

$vectors
[,1] [,2]
[1,] 0.04540086 -0.99896885
[2,] 0.99896885 0.04540086

> ei = eigen(s) # 결과를 ei에 저장, ei는 list
> ei[[1]] # ei의 첫번째 데이터 집합, list에서는 [[]]이용
[1] 379.31171 34.02829
> ei$values # ei의 values 데이터 집합
[1] 379.31171 34.02829
> ei[[1]][1] # 첫번째 고유값
[1] 379.3117
> ei$values[1] # 첫번째 고유값
[1] 379.3117
> ei[[2]] # ei의 두번째 데이터 집합
[,1] [,2]
[1,] 0.04540086 -0.99896885
[2,] 0.99896885 0.04540086
> ei$vectors # ei의 vector 데이터 집합
[,1] [,2]
[1,] 0.04540086 -0.99896885
[2,] 0.99896885 0.04540086
> ei[[2]][2,] # 두번째 고유벡터
[1] 0.99896885 0.04540086
> ei$vectors[2,] # 두번째 고유벡터
[1] 0.99896885 0.04540086
>
>
> # 2.9 배열
> g <- array(1:24, c(4,3,2)) # 배열 생성
> g
, , 1

[,1] [,2] [,3]
[1,] 1 5 9
[2,] 2 6 10
[3,] 3 7 11
[4,] 4 8 12

, , 2

[,1] [,2] [,3]
[1,] 13 17 21
[2,] 14 18 22
[3,] 15 19 23
[4,] 16 20 24

> attributes(g) # 속성
$dim
[1] 4 3 2

> mode(g) # 자료의 종류
[1] "numeric"
> is.array(g) # 배열인지 확인
[1] TRUE
> dim(g) # dimension
[1] 4 3 2
>
> g[1,,]
[,1] [,2]
[1,] 1 13
[2,] 5 17
[3,] 9 21
>
> # 2.10 반복문
>
> # 2.10.1 for()를 이용한 루핑
>
> start <- 100 # 100에서 200까지 구하기
> end <- 200
> isum <- 0
> for(i in start:end) {
+ isum <- isum + i
+ }
> isum
[1] 15150
>
> for ( i in 5:8) { # 5^2, ..., 8^2 구하기
+ print(i^2)
+ }
[1] 25
[1] 36
[1] 49
[1] 64
>
> # 2.10.2 while()을 이용한 루핑
>
> # 1에서 n까지의 합, 합이 100을 넘은 최소값
>
> n = 0
> sum.sofar = 0
> while(sum.sofar <= 100) {
+ n = n + 1
+ sum.sofar = sum.sofar + n
+ }
> n
[1] 14
> sum.sofar
[1] 105
>
> # 2.10.3 repeat()를 이용한 루핑
>
> # 1에서 n까지의 합, 합이 100을 넘은 최소값
>
>
> n = 0
> sum.sofar = 0
> repeat{
+ n = n + 1
+ sum.sofar = sum.sofar + n
+ if (sum.sofar > 100) break
+ }
> n
[1] 14
> sum.sofar
[1] 105
>
> # 2.11 조건문 (if else)
>
> # x의 원소가 양수이면 pos에 1, 아니면 0저장.
>
> x = c(1, -2, -3, 4, 5)
> pos = rep(0, 5)
> for (i in 1:5) {
+ if (x[i] > 0) pos[i] = 1
+ else pos[i] = 0
+ }
> pos
[1] 1 0 0 1 1
>
> # 2.12 결측값
>
> x = c(1, 6, 2, NA) # 결측값의 입력
> is.na(x) # 결측값의 위치
[1] FALSE FALSE FALSE TRUE
> x[x > 2] # x의 원소 중 2를 초과한 값 뽑기. NA도 포함됨
[1] 6 NA
> mean(x) # 결측값 때문에 평균계산 못함
[1] NA
> mean(x, na.rm = TRUE) # 결측값 제외하고 평균 구하기
[1] 3
> xx = na.omit(x) # 결측값을 제외한 벡터 만들기
>
> rank(x) # 순위
[1] 1 3 2 4
> rank(x, na.last = TRUE) # 결측값 순위 마지막
[1] 1 3 2 4
> rank(x, na.last = FALSE) # 결측값 순위 첫째
[1] 2 4 3 1
>
> # 2.13 데이터 프레임
>
> # 각 열마다 서로 다른 자료형(mode)을 가질 수 있는 구조 : list와 같음
> # 그러나 테이블 형태 : list와 다른 점
>
> data(OrchardSprays)
> OrchardSprays
decrease rowpos colpos treatment
1 57 1 1 D
2 95 2 1 E
3 8 3 1 B
4 69 4 1 H
5 92 5 1 G
6 90 6 1 F
7 15 7 1 C
8 2 8 1 A
9 84 1 2 C
10 6 2 2 B
11 127 3 2 H
12 36 4 2 D
13 51 5 2 E
14 2 6 2 A
15 69 7 2 F
16 71 8 2 G
17 87 1 3 F
18 72 2 3 H
19 5 3 3 A
20 39 4 3 E
21 22 5 3 D
22 16 6 3 C
23 72 7 3 G
24 4 8 3 B
25 130 1 4 H
26 4 2 4 A
27 114 3 4 E
28 9 4 4 C
29 20 5 4 F
30 24 6 4 G
31 10 7 4 B
32 51 8 4 D
33 43 1 5 E
34 28 2 5 D
35 60 3 5 G
36 5 4 5 A
37 17 5 5 C
38 7 6 5 B
39 81 7 5 H
40 71 8 5 F
41 12 1 6 A
42 29 2 6 C
43 44 3 6 F
44 77 4 6 G
45 4 5 6 B
46 27 6 6 D
47 47 7 6 E
48 76 8 6 H
49 8 1 7 B
50 72 2 7 G
51 13 3 7 C
52 57 4 7 F
53 4 5 7 A
54 81 6 7 H
55 20 7 7 D
56 61 8 7 E
57 80 1 8 G
58 114 2 8 F
59 39 3 8 D
60 14 4 8 B
61 86 5 8 H
62 55 6 8 E
63 3 7 8 A
64 19 8 8 C
> is.data.frame(OrchardSprays) # 데이타 프레임인지 확인
[1] TRUE
> mode(OrchardSprays) # mode는 list로 나옴
[1] "list"
> names(OrchardSprays) # 변수명 확인
[1] "decrease" "rowpos" "colpos" "treatment"
> row.names(OrchardSprays) # 행의 이름 확인, 특별한 이름이 없으므로 숫자가 나옴
[1] "1" "2" "3" "4" "5" "6" "7" "8" "9" "10" "11" "12" "13" "14"
[15] "15" "16" "17" "18" "19" "20" "21" "22" "23" "24" "25" "26" "27" "28"
[29] "29" "30" "31" "32" "33" "34" "35" "36" "37" "38" "39" "40" "41" "42"
[43] "43" "44" "45" "46" "47" "48" "49" "50" "51" "52" "53" "54" "55" "56"
[57] "57" "58" "59" "60" "61" "62" "63" "64"
> dim(OrchardSprays) # 자료의 수와 변수의 수
[1] 64 4
> nrow(OrchardSprays) # 자료의 수
[1] 64
> ncol(OrchardSprays) # 변수의 수
[1] 4
>
>
> # 2.14 내장 데이터 셋 읽기
>
> data() # 내장 데이터 셋의 종류 확인
> data(Orange) # Orange 데이터 셋 불러오기
> dim(Orange) # 자료의 수와 변수의 수 확인
[1] 35 3
>
> # 2.15 데이터 파일 읽기와 결과 파일 만들기
>
> # 2.15.1 txt 파일 데이터를 읽을 경우
>
> zzz = read.table("data1.txt", header = TRUE) # 텍스트 자료를 데이타 프레임으로 불러오기
> zzz
id x y
1 1 1 2
2 2 2 3
3 3 3 4
4 4 4 5
5 5 5 6
6 6 6 7
7 7 7 8
8 8 8 9
9 9 9 10
10 10 10 11
> attributes(zzz) # 변수이름, 데이터 프레임, 행이름 확인
$names
[1] "id" "x" "y"

$class
[1] "data.frame"

$row.names
[1] 1 2 3 4 5 6 7 8 9 10

> zzz$x # 변수 x 확인
[1] 1 2 3 4 5 6 7 8 9 10
> zzz$x[2] # 변수 x의 두번째 자료 확인
[1] 2
> zzz[[3]] # 세번째 변수 확인
[1] 2 3 4 5 6 7 8 9 10 11
>
>
> # 2.15.2 Excel 파일 데이터를 읽을 경우
>
> zz = read.csv("data1.csv", header = TRUE, sep = ",")
> zz
id x y
1 1 1 2
2 2 2 3
3 3 3 4
4 4 4 5
5 5 5 6
6 6 6 7
7 7 7 8
8 8 8 9
9 9 9 10
10 10 10 11
>
> # 2.15.3 결과 파일 만들기
>
> cat("data set example", "\n",
+ "x = ", zzz$x, "\n",
+ "y = ", zzz$y,
+ file = "out1.txt") # cat 함수 이용
>
> write.table(zzz, file = "out2.txt",row.names = FALSE) # write.table 함수 이용
>
>
> # (1) txt로 저장
>
> mydef = c(1,2,3)
> write.table(mydef, "out3.txt", sep=",", row.names = FALSE)
>
> # (2) csv로 저장
> my1 = c(1,2,3)
> my2 = c(4,5,6)
> write.table(cbind(my1, my2), "out4.txt", sep = ",", row.names = FALSE)
>
> # 2.16 데이터셋 합치기
>
> authors <- data.frame(
+ surname = I(c("Tukey", "Venables", "Tierney", "Ripley", "McNeil")),
+ nationality = c("US", "Australia","US","UK","Australia")
+ )
> authors
surname nationality
1 Tukey US
2 Venables Australia
3 Tierney US
4 Ripley UK
5 McNeil Australia
> books <- data.frame(
+ name = I(c("Tukey", "Venables", "Tierney", "Ripley", "McNeil")),
+ year = c(1976,1995,1996,1998,2000)
+ )
> books
name year
1 Tukey 1976
2 Venables 1995
3 Tierney 1996
4 Ripley 1998
5 McNeil 2000
>
> # 두 데이터 프레임을 surname, name을 기준으로 merge하기
> d = merge(authors, books, by.x = "surname", by.y = "name")
> d
surname nationality year
1 McNeil Australia 2000
2 Ripley UK 1998
3 Tierney US 1996
4 Tukey US 1976
5 Venables Australia 1995
>
> authors2 <- data.frame(
+ surname = I(c("Tukey", "Venables", "Tierney", "Ripley", "McNeil", "Park")),
+ nationality = c("US", "Australia","US","UK","Australia","Korea")
+ )
> authors2
surname nationality
1 Tukey US
2 Venables Australia
3 Tierney US
4 Ripley UK
5 McNeil Australia
6 Park Korea
>
> books2 <- data.frame(
+ name = I(c("Tukey", "Venables", "Tierney", "Ripley", "McNeil", "Kim")),
+ year = c(1976,1995,1996,1998,2000,2008)
+ )
> d2 = merge(authors2, books2, by.x = "surname", by.y = "name") # all = TRUE를 쓰지 않은 merge
> d2 # 결측값이 있는 행을 제외
surname nationality year
1 McNeil Australia 2000
2 Ripley UK 1998
3 Tierney US 1996
4 Tukey US 1976
5 Venables Australia 1995
>
> d3 = merge(authors2, books2, by.x = "surname", by.y = "name", all = TRUE) # all = TRUE를 사용한 merge
> d3 # 결측값이 있는 행도 표시
surname nationality year
1 Kim <NA> 2008
2 McNeil Australia 2000
3 Park Korea NA
4 Ripley UK 1998
5 Tierney US 1996
6 Tukey US 1976
7 Venables Australia 1995
>
>
> # 2.17 객체 관리
>
> # 2.17.1 객체 리스트
>
> ls() # 작업공간에 저장되어 있는 객체 목록 표시
[1] "a" "a_s" "authors" "authors2"
[5] "b" "books" "books2" "cabbages"
[9] "cabbages1" "cabbages2" "cabbages3" "d"
[13] "d2" "d3" "da" "e"
[17] "ei" "end" "exp.fact" "f.log"
[21] "fact" "fact1" "fact2" "family"
[25] "g" "i" "id" "isum"
[29] "k_score" "k_score2" "my1" "my2"
[33] "mydef" "n" "Orange" "OrchardSprays"
[37] "pos" "s" "score" "start"
[41] "sum.sofar" "t1" "w" "x"
[45] "x.const_1" "xx" "y" "zz"
[49] "zzz"
>
> # 2.17.2 데이터 객체 지우기
>
>
>
>
>