1. No category

C 와 R 을 이용한 통계프로그래밍 (Version 0.1)딱
김진석2
1본
note 는 동국대학교 정보통계학과 학부 강의용으로 만들어졌으며, 저자의 허락없이 무단
배포를 금합니다.
2 Assistant Professor, Department of Statistics and Information Science, Dongguk University,
Gyeongju, Korea. E-mail:[email protected], Homepage: datamining.dongguk.ac.kr
딲
차례
제I편
Basic C language
9
장 C 언어를 위한 준비
딱 절
땃 의 역사 딺 땃 의 탄생 딮 딮 딮 딮 딮 딮
딲 절
땃 의 역사 딺 유닉스 딮 딮 딮 딮 딮 딮 딮
딳 절
왜땃 를 배워야하는가 딮 딮 딮 딮 딮 딮
딳딮딱
땃 의 유용성 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딳딮딲
땃 의 단점 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
제 딴 절
프로그램 개발과정 딮 딮 딮 딮 딮 딮 딮
제 딵 절
땖땩땳땵땡땬 땓땴땵땤땩땯 와 땍땩땮땇땗 이용 딮
딮
딮
딮
딮
딮
딮
딮
11
딱딱
딱딱
딱딲
딱딲
딱딲
딱딳
딱딵
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
17
딱딷
딱딸
딲따
딲따
딲딱
딲딱
딲딱
딲딱
딲딲
딲딲
딲딳
딲딳
딮
딮
딮
딮
25
딲딵
딲딶
딲딶
딲딷
제 1
제
제
제
제 2 장 변수, 상수, 자료형
제 딱 절
땃 프로그램의 구조 딮
제 딲 절
자료형 딮 딮 딮 딮 딮 딮 딮 딮
딲딮딱
문자형 딮 딮 딮 딮 딮 딮 딮
딲딮딲
정수 딮 딮 딮 딮 딮 딮 딮 딮
딲딮딳
부동형 딮 딮 딮 딮 딮 딮 딮
제 딳 절
상수 딮 딮 딮 딮 딮 딮 딮 딮 딮
딳딮딱
정수딬 실수 상수 딮 딮
딳딮딲
문자딬 문자열 상수 딮
제 딴 절
변수 딮 딮 딮 딮 딮 딮 딮 딮 딮
딴딮딱
변수 생성 규칙 딮 딮
딴딮딲
변수 초기화 딮 딮 딮 딮
제 딵 절
연습문제 딮 딮 딮 딮 딮 딮 딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
제 3 장 전처리기와 입출력 함수
제 딱 절
전처리기 딨땰땲땥딭땰땲땯땣땥땳땳땯땲딩
딱딮딱
딣땩땮땣땬땵땤땥 딮 딮 딮 딮 딮 딮 딮 딮
딱딮딲
딣땤땥딌땮땥 딮 딮 딮 딮 딮 딮 딮 딮
딱딮딳
매크로 함수 딮 딮 딮 딮 딮 딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딳
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
전처리 지시자 딺 조건부 컴파일 지시자 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딲딷
입출력 함수 딺 표준 입출력 함수 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딲딸
딲딮딱
땰땲땩땮땴땦딨딩 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딲딸
딲딮딲
땳땣땡땮땦딨딩딺 표준 입력 함수 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딳딱
딱딮딴
제 딲 절
제 4 장
연산자와 수식
33
제 딱 절
연산자 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딳딳
제 딲 절
대입 연산자 딨딽딩 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딳딴
제 딳 절
산술연산자 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딳딴
제 딴 절
증가딬 감소 연산자 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딳딵
제 딵 절
관계 연산자 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딳딶
제 딶 절
논리 연산자 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딳딷
제 딷 절
조건 연산자 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딳딷
제 딸 절
비트연산자 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딳딸
제 딹 절
기타연산 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딳딹
제 딱따 절
연습문제 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딳딹
제 5 장
제어문
제 딱 절
41
땩땦 딮딮딮 땥땬땳땥 문 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딴딱
다중 땩땦 ∼ 땥땬땳땥 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딴딱
switch 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딴딲
주의사항 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딴딳
제 딳 절
while 문 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딴딳
제 딴 절
do ... while 문 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딴딴
제 딵 절
for 문 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딴딵
루프의 제어 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딴딶
연습문제 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딴딷
딱딮딱
제 딲 절
딲딮딱
딵딮딱
제 딶 절
배열과 포인터
제 6 장
제 딱 절
49
배열 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딴딹
딱딮딱
배열의 특징 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딴딹
딱딮딲
배열의 필요성 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딴딹
포인터 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딵따
딲딮딱
번지 연산자 (&, *) 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딵딱
딲딮딲
포인터의 형 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딵딱
딲딮딳
배열과 포인터 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딵딱
실습 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딵딲
제 딲 절
제 딳 절
딴
제 7 장
메모리 할당과 해제
제 딱 절
53
메모리 할당 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딵딳
딱딮딱
malloc() 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딵딴
딱딮딲
calloc() 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딵딵
딱딮딳
땲땥땡땬땬땯땣 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딵딶
메모리 해제 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딵딶
제 딲 절
제 8 장
구조체 (structure)
제 딱 절
59
구조체의 구조딬 선언딬 초기화 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딶따
딱딮딱
구조체 선언 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딶따
딱딮딲
구조체의 멤버참조 및 복사 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딶딱
딱딮딳
구조체 초기화 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딶딲
딱딮딴
매개변수가 구조체인 함수 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딶딲
구조체 배열과 구조체 포인터 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딶딳
딲딮딱
구조체 포인터에 의한 멤버참조 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딶딳
딲딮딲
구조체 포인터의 메모리 할당 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딶딳
딲딮딳
구조체의 크기 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딶딴
공용체 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딶딴
제 딲 절
제 딳 절
제 9 장
함수
제 딱 절
67
함수의 구조 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딶딷
딱딮딱
매개변수 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딶딸
딱딮딲
함수를 작성하는 순서 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딶딸
함수의 호출 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딶딹
딲딮딱
값에 의한 호출 (Call by Value) 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딶딹
딲딮딲
참조에 의한 호출 (Call by Reference) 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딷따
제 딲 절
제 10 장 File Handling
제 딱 절
71
외부파일의 입출력 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딷딱
딱딮딱
땦땧땥땴땳딨 딩 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딷딳
딱딮딲
땦땧땥땴땣딨딩딮 땧땥땴땣딨딩 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딷딳
딱딮딳
파일의 마지막을 찾는 방법 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딷딳
딱딮딴
땳땰땲땩땮땴땦딨땳땳땣땡땮땦딩 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딷딳
제 II 편
R 프로그래밍
75
제 11 장 서언
77
딵
제 12 장 Download & Install the R system
제 딱 절
땒땧땵땩 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
제 딲 절
땄땯땷땮땬땯땡땤 딦 땉땮땳땴땡땬땬 땴땨땥 땐땡땣땫땡땧땥 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
79
딸따
딸따
제 13 장 기본 유틸리티
83
제 14 장 객체 (R objects)
제 딱 절
땄땡땴땡 땯땢땪땥땣땴 의 땳땴땯땲땡땧땥 땭땯땤땥 딮
제 딲 절
땶땥땣땴땯땲 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
제 딳 절
땭땡땴땲땩땸 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
제 딴 절
땤땡땴땡 땦땲땡땭땥 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
제 딵 절
땒 땯땰땥땲땡땴땯땲땳 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딮
딮
딮
딮
딮
85
딸딵
딸딷
딸딸
딸딸
딸딸
딮
딮
딮
딮
91
딹딱
딹딱
딹딲
딹딲
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
제 15 장 R programming
제 딱 절
조건문 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
제 딲 절
순환문 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
제 딳 절
땒 땆땵땮땣땴땩땯땮땳딺 땴땷땯 땳땩땭땰땬땥 땥땸땡땭땰땬땥땳
제 딴 절
땃땯땭땭땯땮 땕땳땥땦땵땬 땆땵땮땣땴땩땯땮땳 딮 딮 딮 딮 딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
제 16 장 R 에서 C code 부르기
93
제 17 장 R Graphics
제 딱 절
땈땩땧땨딭땬땥땶땥땬 땰땬땯땴땴땩땮땧 땣땯땭땭땡땮땤땳
제 딲 절
때땯땷딭땬땥땶땥땬 땰땬땯땴땴땩땮땧 땣땯땭땭땡땮땤땳
제 딳 절
땉땮땴땥땲땡땣땴땩땮땧 땷땩땴땨 땧땲땡땰땨땩땣땳 딮 딮
제 딴 절
땕땳땩땮땧 땧땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲땳 딮 딮
제 딵 절
땇땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲땳 땬땩땳땴 딮 딮 딮
제 딶 절
땄땥땶땩땣땥 땤땲땩땶땥땲땳 딮 딮 딮 딮 딮 딮 딮 딮 딮
제 딷 절
땄땹땮땡땭땩땣 땧땲땡땰땨땩땣땳 딮 딮 딮 딮 딮 딮 딮
제 III 편
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
C 와 R 을 이용한 기초통계의 계산
제 18 장 확률과 확률분포
제 딱 절
확률 딨땰땲땯땢땡땢땩땬땩땴땹딩 의 고전적 정의 딮 딮 딮
제 딲 절
공리적 정의 딨 콜모고로프 (Kolmogorov)
제 딳 절
확률에 관한 성질 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
제 딴 절
확률변수 및 확률분포 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
제 딵 절
확률질량함수 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
제 딶 절
확률밀도함수 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딶
딮 딮 딮 딮 딮 딮 딮
딻 딱딹따딳딭딱딹딸딷
딮 딮 딮 딮 딮 딮 딮
딮 딮 딮 딮 딮 딮 딮
딮 딮 딮 딮 딮 딮 딮
딮 딮 딮 딮 딮 딮 딮
97
딹딹
딱따딴
딱따딷
딱따딸
딱딱따
딱딱딵
딱딱딵
117
딮 딮
딮
딮 딮
딮 딮
딮 딮
딮 딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
딮
119
딱딱딹
딱딲따
딱딲따
딱딲따
딱딲딱
딱딲딱
제 딷 절
기대값 (expectation) 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
제 19 장 여러 가지 분포
딱딲딱
123
제 딱 절
균등분포 (uniform distribution) 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딲딳
제 딲 절
베르누이분포 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딲딴
제 딳 절
이항분포 (binomial distribution) 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딲딴
제 딴 절
정규분포 (normal distribution) 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딲딶
제 딵 절
지수분포 (exponential distribution) 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딲딸
제 딶 절
감마분포 (gamma distribution) 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딲딸
제 딷 절
땴 분포의 누적확률함수 딨땣땤땦딩 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딳따
제 20 장 기술통계
제 딱 절
135
Boxplot(상자그림) 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
제 21 장 모집단의 평균검증
딱딳딵
137
제 딱 절
모집단의 모평균 추론 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딳딷
제 딲 절
t 검정 (t-test) 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딳딸
딲딮딱
일표본 t 검정 (one sample t-test) 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딳딸
딲딮딲
땔땷땯 땓땡땭땰땬땥 땴딭땴땥땳땴딨표본수가 같을 때딩 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딳딹
딲딮딳
땔땷땯 땓땡땭땰땬땥 땴딭땴땥땳땴딨표본수가 다를 때딩 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딴따
딲딮딴
대응비교 (Paired t-test) 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딴따
제 22 장 카이제곱 검정
141
제 딱 절
독립성검정 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딴딱
제 딲 절
동일성검정 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딴딲
제 23 장 Basic analysis with R
145
제 딱 절
확률분포 딨땐땲땯땢땡땢땩땬땩땴땹 땤땩땳땴땲땩땢땵땴땩땯땮땳딩 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딴딵
제 딲 절
기초통계 딨기술통계 딻 땄땥땳땣땲땩땰땴땩땶땥 땳땴땡땴땩땳땴땩땣땳딩 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딴딶
딲딮딱
줄기딭잎 그림과 상자그림 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딴딶
딲딮딲
땈땩땳땴땯땧땲땡땭 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딴딷
딲딮딳
땒 그래픽
딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딴딸
제 딳 절
분포가정의 진단 딺 정규성 검정 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딴딸
제 딴 절
두 표본의 땴 검정 딨땴땷땯딭땳땡땭땰땬땥 땴땥땳땴땳딩 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딵따
제 딵 절
대응비교 (paired t-test) 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딵딲
제 딶 절
비율검정 및 카이제곱검정 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮
딱딵딳
딷
제 24 장 Linear models
155
제 딱 절
모형 객체와 관련된 일반함수 딨땇땥땮땥땲땩땣 땦땵땮땣땴땩땯땮딩 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딱딵딵
제 딲 절
땁땮땡땬땹땳땩땳 땯땦 땶땡땲땩땡땮땣땥딨땁땎땏땖땁딩 땡땮땤 땭땯땤땥땬 땣땯땭땰땡땲땩땳땯땮 딮 딮 딮 딮 딮 딮 딮 딮 딱딵딶
제 딳 절
땁땎땏땖땁 땴땡땢땬땥땳 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딮 딱딵딷
딸
제I편
Basic C language
딹
제1장
C 언어를 위한 준비
제1절
C 의 역사 : C 의 탄생
딱딹딷딲 년 유닉스 딨땏땓딩 를 만들기 위해서 탄생
• 땂땃땐때딨딱딹딶딹딩 → 땂 딨딱딹딷따딩 → 땃 딨딱딹딷딲딩
• 유닉스를 디자인하던 켄톰슨 딨땋땥땮땮땥땴땨 땔땨땯땭땰땳땯땮딩 이 절친한 친구 데니스 리치 딨땄땥땮딭
땮땩땳 땒땩땴땣땨땩땥딩 에게 유닉스를 위한 언어 요청
• 데니스리치가 땂땃땐때 딨땍땡땲땴땩땮 땒땩땣땨땡땲땤땳딬 딱딹딶딶딩 을 추천
• 켄톰슨이 땂땃땐때 을 발전시켜 땂땥땬땬 때땡땢땳 의 이니셜을 딴 땂 를 개발
• 데니스리치가 땂 를 땃 로 발전시킴
제2절
C 의 역사 : 유닉스
• 유닉스 딨땕땎땉땘딩 는 초창기 땠유닉스딧가 아닌 땠멀틱스 딨땍땵땬땴땩땣땳딩 라고 불림
• 다중 땃땐땕딬 메모리 공유딬 땉딯땏 자원 공유딬 가상메모리딬 다중 언어 지원딬 보안딬 관계형
데이터 베이스딬 다중 사용자의 기능을 구현하려고 시도하였으나 그 당시의 기술로는
구현 불가능하여 실패함딮
• 멀틱스가 실패하자 이를 안타까워 했던 켄톰슨이 땐땄땐딭딷 에 멀틱스를 이식하고 조금
씩 발전시켜 나감딮
• 멀틱스는 이때부터 유닉스 딨땕땮땩땣땳딻 땕땮땩땰땬땥땸땥땤 땉땮땦땯땲땭땡땴땩땯땮 땡땮땤 땃땯땭땰땵땴땩땮땧 땓땹땳땴땥땭딩
라고 불렸고
딱딱
• 거세된 땍땵땬땴땩땣땳 라는 땕땮땩땣땳 딨내시 딨땥땵땮땵땣땨땳딩 의 동음이의어딩 의 안좋은 말장난 때문에딬
이름은 유닉스 딨땕땮땩땸딩 로 바뀌었다딮
• 유닉스는 처음에 어셈블리로 작성되었음 딨현재 유닉스는 딹따딥 가 땃 언어 딱따딥 가 어셈
블리어로 구성됨딩
• 딱딹딸딹 년 핀란드 헬싱키대학에 재학 중이던 리누스 토발즈 딨때땩땮땵땸 땔땯땲땶땡땬땤땳딩 에 의해서
만들어진 공개 땏땓 초창기 리눅스는 주로 개인용 컴퓨터에서 사용되었음
• 리눅스의소스코드는 완전무료로 공개되었으며 수 많은 프로그래머에 의해서 계속 업
그레이드 되고 있음
• 리눅스는 땇땎땕딨땇땮땵 땎땯땴 땕땮땩땸딩 를 표방하였고딬 무료배포와 소스 완전 개방에 의해서
대학과 개발자에게 급속히 확산됨
제3절
3.1
왜C 를 배워야하는가
C 의 유용성
딱딮 실행 속도가 빠름 딺 어셈블리어를 제외한 여타의 언어에 비해서 상대적으로 높은 속
도를 냄
딲딮 실행파일의 크기가 작음 딺
다른 언어에 비해서 실행파일의 크기가 작다딮 일반적인 상황에서는 실행파일의 크기
는 문제가 되지 않지만 임베디드 시스템에서는 중요한 요소가 됨
딳딮 작성하기 쉬움 딺 어셈블리어보다 상대적으로 배우거나 작성하기 쉬움
딴딮 하드웨어를
하드웨어를
하드웨어를
작성하기가
다루기가 쉬움 딺
다룰 수 있는 많은 기능을 가짐
제어하는 가장 강력한 언어는 어셈블리어이지만 어셈블리어는 배우거나
까다로움
딵딮 다른 플랫폼으로 이식하기 쉬움 딺 이미 작성된 프로그램을 다른 환경 딨유닉스딬 윈도우딬
리눅스딩 으로 이식하기가 쉬움
3.2
C 의 단점
딱딮 배우기가 어려움 딺 어셈블리어보다는 쉽지만 다른 언어에 비해서는 배우기가 어려운
편임
딱딲
그림 딱딮딱딺 땐땲땯땧땲땡땭땩땮땧 땐땲땯땣땥땳땳
딲딮 초보자가 작성하기 어려움 딺 세세한 작업을 프로그래머가 모두 챙겨야 함 딭 메모리 할
당 및 해제를 자동으로 해주지 않음
알고리즘에 문제가 발생하면 에러를 잡기가 어려움
포인터 부분을 프로그램 한 후 문제가 발생하면 문제점을 찾기가 어려움
딳딮 그래픽 작업이 어려움 딺 땃 는 그래픽과 극을 달림딬 그래픽이 필요하면 다른 언어의 힘
을 빌려야 함
제4절
프로그램 개발과정
• 소스코드 작성 딺 에디터 딨땅땤땩땴땯땲딩 를 이용하여 프로그램 작성
• 컴파일러 실행 딺 목적코드를 생성 딨실행파일의 중간 단계딩
• 오류 수정 딺 컴파일러를 수행한 후 코드의 오류를 수정
• 링커 실행 딺 실행파일을 생성하는 단계 딭 여러 파일 딨목적코드딩 을 하나로 합치는 의미
를 가지고 있음
• 실행파일 수행
딱딮 소스코드 작성 딺 에디터 딨땅땤땩땴땯땲딩 를 이용하여 프로그램 작성딬 땃 의 소스코드는 딮땣 로 끝
남
딱딳
그림 딱딮딲딺 땐땲땯땧땲땡땭땩땮땧 땐땲땯땣땥땳땳
# include <stdio.h>
main()
{
printf(\Welcome to the C World.");
}
위의 프로그램은 화면에 땠땗땥땬땣땯땭땥 땴땯 땴땨땥 땃 땷땯땲땬땤딮딧가 출력됨
딲딮 컴파일러 실행 딺 컴파일러를 이용하여 목적 딨땏땢땪땥땣땴딩 코드를 생성
딨땡딩 컴파일 딺 사람이 이해하는 소스코드를 기계가 이해할 수 있는 기계어로 번역하는
과정 컴파일을 수행하는 행위자를 땠컴파일러딧라고 함
딨땢딩 목적 딨땏땢땪땥땣땴딩 코드 딺 컴파일러에 의해서 기계어가 이해할 수 있는 상태로 변환된
파일딬 일반적으로 딮땯 가 생성됨딬 실행파일을 생성하는 중간단계
딳딮 오류수정 딺 컴파일을 수행하는 도중 발생되는 에러나 문제점을 디버거 딨땄땥땢땵땧땧땥땲딩 의
의해서 해결하기도 함
딴딮 링커 실행
딨땡딩 목적코드를 실행파일로 변환 딺 딮땯 로 구성된 목적코드를 하나의 실행파일로 만들
어 냄
딨땢딩 다수의 목적코드를 하나로 결합 딺 일반적으로 다수의 목적코드를 링커가 하나로
합쳐서 실행파일로 만들어 냄
딱딴
딵딮 실행파일 실행 딺 윈도우 환경 딺 딪딮땥땸땥 로 생성딬 유닉스 환경 딺 땡딮땯땵땴 로 생성
제5절
Visual Studio 와 MinGW 이용
시작화면
프로젝트 생성
땳땡땭땰땬땥딮땣 생성
땳땡땭땰땬땥딮땣 편집
프로그램 작성
컴파일딬 링크딬 실행
그림 딱딮딳딺 땖땃딫딫 이용
땍땩땮땇땗 는 땍땩땮땩땭땡땬땩땳땴 땇땎땕 땦땯땲 땗땩땮땤땯땷땳 의 약자로 http://www.parinyasoft.com/
혹은 강의홈페이지 딨http://datamining.dongguk.ac.kr/lectures/spring2008/c.htm딩
에서 다운로드 받아 설치
딱딵
초기화면
프로젝트 생성
소스코드
컴파일 및 실행
그림 딱딮딴딺 땍땩땮땇땗 이용
연습문제 1
딱딮 땃 의 장점과 단점에 대해서 설명하시오딮
딲딮 컴파일과 링크에 대해서 설명하시오딮
딳딮 소스 프로그램딬 오브젝트 딨목적딩 프로그램딬 실행 프로그램의 차이점을 설명하시오딮
딴딮 자신의 이름을 출력하는 프로그램을 작성하시오딮
딵딮 자신의 이름을 출력하는 함수를 작성하고 오브젝트 파일을 생성하시오딮
딶딮 땭땡땩땮딨딩 함수와 자신의 이름을 출력하는 함수를 링커로 결합하여 하나의 실행파일을
생성하시오딮
딱딶
제2장
변수, 상수, 자료형
제1절
C 프로그램의 구조
땃 프로그램 이해의 필수 요소
#include <stdio.h> // Header file (1)
main() // main 함수(2)
{
// 변수의 선언, 정의, 초기화 (3)
int i;
int sum=0;
for(i=0;i<10;i++)
{
sum += i;
printf("0 부터 %d까지의 합은 = %d\n", i, sum);
}
}
딱딮 헤더 파일이란 무엇인가 딿
#include <stdio.h>
• 땃 의 가장 첫 머리에 옴
• 헤더파일을 추가할 때는 가장 앞에 항상 딣 추가
• 헤더파일은 전처리기가 땳땴땤땩땯딮땨 를 찾아 소스 코드 앞에 추가함
딲딮 함수란 무엇인가 딿
딱딷
main()
{
}
• 수학에서의 함수 성질과 유사
• 함수에 값을 넘기고 결과 값을 리턴 받음
• 땃 는 결과 값을 받지 않도록 설정하거나 결과값을 무시할 수 있음
• 예약 함수
printf(), fprintf(), sprintf(), scanf() ...
puts(), gets(), getchar() ...
...
딳딮 변수란 무엇이고 초기화는 어떻게 하는가 딿
int i, sum = 0
• 변수는 변하는 수를 지칭
• 변수를 정의할 때 값을 할당하는 행위를 초기화라 함
• 초기화를 해주지 않으면 쓰레기 값에 의해서 말썽을 일으킴
• 초기화 방법
int imsi_int = 0;
float imsi_float = 7.5;
제2절
자료형
• 정보를 저장하는 범위 딨단위딩 결정
• 자료형에 따라서 메모리에 할당되는 범위가 다름
• 정보저장 단위 딺
– 땂땩땴 딨땂땩땮땡땲땹 땄땩땧땩땴딩딺 컴퓨터가 인식하는 최소 단위딬 따 과 딱 로 표현되는 정보의
단위
딱딸
– 땂땹땴땥딺 딸딬 딹 개의 땢땩땴 단위를 묶어서 하나의 단위로 구성
기계가 인식하는 비트를 사람이 인식할 수 있는 정보의 단위로 재 구성함
딸땢땩땴 로 하나의 바이트를 구성하면 모두 딲딵딶 가지의 표현식을 사용할 수 있음
바이트 딨딸 땢땩땴땳딩 → 딲딵딶 가지 표현
0000
0000
0000
0000
0000
...
0001
0010
0011
0100
0101
– 땍땥땧땡 땂땹땴땥딬 땇땩땧땡딬 땔땥땲땡딬딮딮딮
딱땍 딽 딱따딲딴땋땢땹땴땥땳 딽 딱따딲딴 × 딱따딲딴 땢땹땴땥땳 딽 딱딬따딴딸딬딵딷딶 땢땹땴땥땳
자료형이 왜 필요한가 딿
• 자료형의 개념이 없으면 메모리 낭비를 초래
• 자료형의 부적절한 사용으로 인한 낭비 예
• 정확한 자료형의 사용으로 메모리를 효율적으로 사용가능
메모리 크기 : 땳땩땺땥땯땦딨딩 땦땵땮땣땴땩땯땮
int main ()
{
printf("size
printf("size
printf("size
printf("size
printf("size
printf("size
printf("size
of
of
of
of
of
of
of
a
a
a
a
a
a
a
char is %d\n", sizeof(char));
short is %d\n", sizeof(short));
int is %d\n", sizeof(int));
long is %d\n", sizeof(long));
float is %d\n", sizeof(float));
double is %d\n", sizeof(double));
long double is %d\n", sizeof(long double));
딱딹
표 딲딮딱딺 자료형의 종류
기본형 자료형
땳땩땺땥딨땢땹땴땥딩
표현범위
문자형 땣땨땡땲
딱
정수형 땳땨땯땲땴
딲
−딲15 ∼ 딲15 − 딱
땵땮땳땩땧땮땥땤 땳땨땯땲땴
딲
따 ∼ 딲16
땩땮땴
딴
−딲31 ∼ 딲31 − 딱
땵땮땳땩땧땮땥땤 땩땮땴
딴
따 ∼ 딲32
땬땯땮땧
딸
−딲63 ∼ 딲63 − 딱
땵땮땳땩땧땮땥땤 땬땯땮땧
딸
따 ∼ 딲64
부동
딍땯땡땴
딴
소수점형 땤땯땵땢땬땥
딸
땬땯땮땧 땤땯땵땢땬땥
딸
printf("size of a void * is %d\n", sizeof(void *));
return 0;
}
2.1
문자형
하나의 문자를 다루기 위하여 사용
옳은 예
char imsi;
imsi = ’a’; // imsi에 문자 ’a’가 저장된다.
imsi = ’5’?; // imsi에 문자 ’5’가 저장된다.
잘못된 예
char imsi;
imsi = ’jung’?; // imsi에 문자열은 저장될 수 없다.
imsi = 97?; // (??)
2.2
정수
소수점이 없는 수 딨음의 정수와 양의 정수가 있음딩
모든 수는 컴퓨터에 딲 진수로 저장됨
정수 딲따따딵 가 메모리에 저장되는 예
2005 (2바이트 표현)
딲따
0000 0111 1101 0101
2005 (16진수 표현)
0x07D5
2005를 2진수로 변환
땎땯땴땥딺 딧땡딧 라는 문자는 아스키 딨땁땓땃땉땉딩 값 딹딷 이며 딲 진수 따딱딱따 따따따딱 로 저장됨 그러므로
딧땡딧 딫 딱 과 같은 연산도 가능함 딨문자에 숫자를 더하는 연산 가능딩
2.3
부동형
소수부가 있는 형태로써 형 확장에 주의 해야 함
int
int_one, int_two, int_sum;
float float_one, float_two, float_sum;
int int_sum;
flaot float_one, float_two, float_sum;
제3절
3.1
상수
정수, 실수 상수
정수 상수: 77, 654, 039, 0x47 //소수점이 없는 형태
실수 상수: 4.15, 54.4E10
//소수점이 있는 형태
3.2
문자, 문자열 상수
문자 상수: ’y’, ’7’, ’\n’ //단일의 문자를 작은 따옴표로 둘러싸서 표현
문자열 상수: "imarchie"
//큰 따옴표
비프음
printf("소리가 납니다. \a");
개행처리
printf("문자열과 문자열 사이의\n개행을 위해서 사용합니다.");
문자열과 문자열 사이의
개행을 위해서 사용합니다.
주의사항 :
딲딱
확장열
\땡
\땢
\땦
\땮
\\
\딧
\딢
표 딲딮딲딺 특별한 문자 상수 딨확장열딬땥땳땣땡땰땥 땳땥땱땵땥땮땣땥딩
땁땓땃땉땉 땣땯땤땥 의미
따땸따딷
비프음을 낸다딮
따땸따딸
커서의 위치를 뒤로 이동시킨다딮 딨땢땡땣땫 땳땰땡땣땥딩
따땸따땣
강제 종이 넘김 기능이 있다딮 딨땆땯땲땭 땆땥땥땤딩
따땸따땡
개행 딨땮땥땷땬땩땮땥딩 을 실행한다딮
따땸딵땣
역슬래쉬가 출력되도록 한다딮
따땸딲땣
작은 따옴표를 출력한다딮
따땸딲딲
큰 따옴표를 출력한다딮
• 문자열의 끝에 널 문자가 포함됨
• 문자열을 큰 따옴표로 감싸면 시스템적으로 주소 값이 반환됨
char imsi = "I am archie";
char *string_imsi = "I am archie";
딢땉 땡땭 땡땲땣땨땩땥딢 를 사용하면 시스템은 딧땉딧 가 저장된 주소를 반환함 첫 번째 예제는 땩땭땳땩
가 주소 값을 받을 수 없으므로 에러 발생
char *string_imsi = "I am archie";
땳땴땲땩땮땧_땩땭땳땩 를 위한 딴 바이트가 할당됨 딨포인터 변수이기 때문에 딱 바이트가 아니라 딴 바
이트딩 문자열 상수 딢땉 땡땭 땡땲땣땨땩땥딢 를 메모리의 어딘가에 저장함 딨여기서는 따땸딲따 ~ 따땸딲딸 라고
가정딩 string _imsi 에 딧땉딧 가 저장된 번지 따땸딲따 이 할당된다딮
제4절
변수
변하는 수를 의미하지만 시스템에서 사용하는 기억장소를 지칭한다딮
변수 생성 규칙
4.1
4.1.1
변수 생성 가능 문자
문자(A ~ Z, a ~ z), 정수 (0 ~ 9), 밑줄 (_)
딲딲
4.1.2
주의사항
• 변수는 위의 것 외의 다른 문자는 올 수 없음 즉딬 딨딣딬 딤딬 딪딬 딭 과 같은 특수문자는
변수로 사용될 수 없음딩
• 예약어를 변수로 가질 수 없음 딨땡땵땴땯딬 땩땮땴딬 딍땯땡땴딬 땷땨땩땬땥 등은 변수로 사용될 수 없음딩
• 컴파일러는 변수의 대딬 소문자를 구별 딨컴파일러는 땩땭땳땩 와 땉땍땓땉 를 다른 변수로 인식딩
• 변수의 첫 문자는 영문자나 밑줄로 시작되어야 함 딨딴딵땩땭땳땩 나 따_땩땭땳땩 같은 변수는 허
용되지 않음딩
• 변수는 사용되기 전에 반드시 선언되어야 함
4.2
변수 초기화
변수의 초기화는 딧반드시딧 필요하지는 않다딮
하지만 초기화가 필요한 곳에서는 꼭 초기화를 해주어야 한다딮
변수 초기화 방법
int
imsi = 0, x = 1, y = 2;
float imsi = 0.0, x = 0., y = 2.5;
char imsi = ’a’, x = 0x20, y = ’5’;
char *imsi = \I’m archie";
int imsi[3] = {5, 7, 3};
char imsi[3] = {’x’, ’y’, ’z’};
char imsi[3] = "xy";
제5절
연습문제
딱딮 자료형이 필요한 이유는 무엇인가 딿
딲딮 땳땩땺땥땯땦 연산자의 역할은 무엇인가 딿
딳딮 아스키 코드 값이 무엇인지 설명하시오딮
딴딮 캐스트 연산자의 역할에 대해 설명하시오딮
딵딮 땩땮땴 땡 딽 딱따딬 땢 딽 딳 일 때 다음의 연산 결과를 적으시오딮
딲딳
그림 딲딮딱딺 변수 초기화를 하지 않았을 때
printf("a
printf("a
printf("a
printf("a
+
/
/
/
b
b
b
b
=
=
=
=
%d\n", a + b);
%d\n", a / b);
%d\n", (float)a / (float)b);
%.1f\n", (float)a / (float)b);
딶딮 초기화란 무엇이고 초기화를 해주지 않았을 때의 위험성을 기술하시오딮
딷딮 딱 딯 딳 은 땃 에서 어떻게 출력되는지 프로그램 하시오딮 딨땩땮땴딬 딍땯땡땴 자료형 적용딩
딸딮 땦땯땲딨딩 문을 이용하여 딱 부터 딱따 까지 출력하시오딮
printf("%d", 1/3 + 1/3 + 1/3);의 출력이 1이 되지 않음을 설명하시오.
딹딮 땣땨땡땲 땯땮땥 딽 딧땡딧딻 일 경우 땡 가 메모리에 저장되는 번지수를 출력하시오딮
딱따딮 정수를 입력하면 다음과 같이 딲 진수로 출력하는 프로그램을 작성하시오딮
7 : 0000 0111
12 : 0000 1100
35 : 0010 0011
딱딱딮 다음과 같이 출력하는 프로그램을 작성하시오딮
a ab abc abcd abcde ...
딲딴
제3장
전처리기와 입출력 함수
제1절
전처리기 (pre-processor)
땰땲땥딨전딭앞딩딬 땰땲땯땣땥땳땳땯땲딨처리기딩 컴파일러 앞에서 먼저 처리함
전처리기가 처리하는 내용
• 전처리 지시자를 처리 딨딣 으로 시작딩
#define ,
#include,
#ifdef, #ifndef,
#if, #else, #endif,
#line, #error, #pragma
• 함수를 처리
sqrt(), atan(), atan2(), exit(), atexit(),
memcpy(), memmove(), va_start(), va_arg()...
• 주석 제거
전처리 지시자의 종류
#define
#include
#ifdef ~ #endif
#if defined(XXX) ~ #endif
#if !defined(XXX) ~ #endif
#undef
딲딵
1.1
#include
외부 땨땥땡땤땥땲 파일을 포함시킴
#include <stdio.h>
//시스템 디렉토리에서 찾음
#include "my_header.h" //현재의 디렉토리에서 찾음
1.2
#define
• 매크로 변수 및 함수 정의 딺 매크로 변수 딨함수딩 를 정의한 데로 사용하겠다는 의미
• 딣땤땥딌땮땥 에서 정의한 것들은 전처리기가 지정한 문자열로 치환함
#define
#define
#define
#define
#define
#define
#define
YEAR 2007
TIME 60
MIN 60
TIME_VLUE TIME * MIN
PRINT printf("%d\n", TIME_VALUE)
PI 3.141519
TRUE 1
주의사항 :
• 여러 라인에 걸쳐서 매크로를 정의할 수 없음
#define
200 *
300
MAX 100 *
\ 를 이용하여 다음 줄로 넘길 수 있음
#define PRINT_BINARY(x) (((x) == 1) ? "ONE" : \
(((x) == 0) ? "ZERO" : "NOT A BINARY"))
• 매크로 변수에 공백을 삽입할 수 없음
#define M AX 100 * 200 * 300 //( X )
#define MAX 100 * 200 * 300
//( O )
딲딶
1.3
매크로 함수
#define
ADD(x, y)
x + y
#define : 매크로 지시자
ADD : 매크로 함수 명 (중간에 공백이 있으면 안됨)
(x, y) : 매크로 함수 인자
x + y : 매크로 몸체
define
MAX(x, y)
(x > y) ? x : y
매크로 함수의 위험성 및 해결방법
• 우선 순위에 의한 위험성
#define MUL(x, y) x * y
printf("%d\n", MUL(4, 6));
printf("%d\n", MUL(2+2, 3+3));
딱 번의 결과 딺 딲딴 딲 번의 결과 딺 딲딴 가 아님딮 딲 번은 다음과 같이 전개되어 결과값이 딱딴
가 됨
printf("%d\n", 2 + 2 * 3 + 6);
• 해결 방법 딨괄호 사용딩
#define MUL(x, y) (x) * (y)
==> printf("%d\n", (2 + 2) * (3 + 3));
1.4
전처리 지시자 : 조건부 컴파일 지시자
#ifdef
...
#endif
매크로 변수 정의 여부에 따라서 컴파일이 수행되거나 수행되지 않도록 함 조건적으로
컴파일 되기 때문에 범위가 필요함 딨딣땥땮땤땩땦 로 처리딩
#ifdef DEBUG
...
(프로그래머가 작성한 프로그램)
...
#endif
딲딷
땄땅땂땕땇 가 매크로 정의되어 있다면 딣땥땮땤땩땦 까지 컴파일 되며 매크로 정의되어 있지 않다
면 컴파일되지 않음
제2절
입출력 함수 : 표준 입출력 함수
printf()
scanf()
입출력은 파일딬 키보드딬 화면딬 테이프 드라이브 등을 통한 입출력을 뜻하고딬 이 중 화면
을 통한 입출력을 표준 입출력이라고 함
2.1
printf()
땰땲땩땮땴땦딺 땰땲땩땮땴 와 땦땯땲땭땡땴땴땥땤 의 합성어
문자딬 숫자딬 문자열딬 부동형 숫자 등 다양하게 출력 가능
자동 개행을 해 주지 않음
자동개행함수 딺땰땵땴땳딨딩
printf("서식 문자열", 인자1, 인자2, 인자3 ...);
서식 문자열은 항상 큰 따옴표를 사용함 서식 문자열에 따라서 인자가 있을 수도 있고
없을 수도 있음 서식 문자열 안에 변환형식문자가 존재하면 인자와 딱딺딱 대응
//변환형식문자가 없는 경우
printf("I’m archie.\nYou are a girl.");
printf("I’m archie.\tYou are a girl.");
I’m archie.
You are a girl.
I’m archie. You are a girl.
서식 지정 문자 딺 출력의 모양을 결정
딲딸
딍땡땧땳 딭
딍땡땧땳 딫
딍땡땧땳 딣
땷땩땤땴땨
땰땲땥땣
표 딳딮딱딺 서식 지정 문자 딺 출력의 모양을 결정
왼쪽 맞춤딮
숫자보다도 문자열 출력에 많이 쓰임
숫자에서 부호를 같이 출력
포인터 딨주소딩 를 출력을 위하여 사용됨딮
딣 는 따땸 를 추가해준다
출력의 폭을 지정딬
출력값보다 크게 잡으면 나머지는 공백으로 채워짐딮
소수자리의 정밀도를 지정딮
지정하지 않으면 소수점 이하 딶 자리까지 출력
땠딮땦딧를 사용하면 소수점 이하는 잘려나감딮
표 딳딮딲딺
자료형
땣땨땡땲
땣땨땡땲 딪
땳땨땯땲땴
땩땮땴
땬땯땮땧
딍땯땡땴
땤땯땵땢땬땥
땬땯땮땧 땤땯땵땢땬땥
땰땯땩땮땴땥땲
변환 형식 문자
땆땯땲땭땡땴 땣땨땡땲땡땣땴땥땲땳
딥땣
딥땳
딥땤
딥땤
딥땬땤
딥땦 땯땲 딥땧 땯땲 딥땥
딥땦 땯땲 딥땧 땯땲 딥땥
딥땬땦 땯땲 딥땬땧 땯땲 딥땬땥
딥땰
%[flags][width][.prec][F|N|h|l]type
flags : ’-’, ’+’, ’ ’, ’#’
width : 출력의 폭을 지정
prec : 출력되는 값의 정밀도를 지정함
F, N, h, l: 입력 크기 지정자
type : 변환형식문자
인자의 값을 10진수로 출력한다(int).
printf("%d", 100);
// 100 출력
%c 인자의 값을 참조하여 문자 하나를 출력한다.
printf("%c", ’y’); // ‘y’문자 출력
printf("%c", imsi); // ASCII 문자출력
%s 널 문자를 만날 때까지 인자의 값을 출력한다.
%d
딲딹
printf("%s", "imarchie");
printf("%s", imsi); // imsi가 가리키는 문자열 출력
%x, %X 인자의 값을 16진수로 출력한다.
printf("%x", 100); // 64
%f 인자의 값을 부동형(float, double)으로 출력한다.
printf("%f", 100); // 100.000000
printf("%f", 0.5); // 0.500000
%% ’%’ 자체를 출력한다.
printf("[%d]", 538);
printf("[%10d]", 538);
printf("[%-10d]", 538);
printf("[%10s]", \archie");
printf("[%-10s]", \archie"); [538]
[
538]
[538
]
[
archie]
[archie
]
printf("[%d]", 538);
printf("[%10d]", 538);
printf("[%-10d]", 538);
printf("[%+10d]", 538);
printf("[%+10d]", -538); [538]
[
538]
[538
]
[
+538]
[
-538]
printf("[%#d]\n", 538);
printf("[%#x]\n", 538);
printf("[%#x]\n", &imsi); [538]
[0x21a]
[0xffbffbdc]
printf("[%10d]", 538);
printf("[%10s]", \archie");
[
538]
딳따
[
archie]
printf("[%f]\n", 538.235);
printf("[%.f]\n", 538.235);
printf("[%10.1f]\n", 538.235);
printf("[%0.2f]\n", 538.235);
printf("[%.1f]\n", 538.235);
printf("[%.2f]\n", 538.235);
[538.235000]
[538]
[
538.2]
[538.24]
[538.2]
[538.24]
2.2
scanf(): 표준 입력 함수
• 땳땣땡땮 과 땦땯땲땭땡땴땴땥땤 의 합성어
• 입력 받을 때 딧딦딧 기호를 잊지 말아야 함
• 문자열을 입력 받는데 사용하지 말아야 함
• 문자열 입력은 땦땧땥땴땳딨딩 사용하는 것이 좋음
#include <stdio.h>
main()
{
char name[512];
printf("이름을 입력하시오 ");
scanf("%s", name);
puts(name);
}
딳딱
딳딲
제4장
연산자와 수식
제1절
연산자
기능별 분류 기호
========================================================
분류
기호
-------------------------------------------------------대입 연산자
=
+=
-=
*=
/=
산술 연산자
+
*
/
%
증감 연산자
++
-관계 연산자
<
<=
>
>=
==
!=
논리 연산자
!
&&
||
조건 연산자
? :
비트 연산자
&
| ^ << >> ~
캐스트 연산자 (형명)
sizeof 연산자 sizeof
========================================================
연산자의 연산순위 딺
========================================================
연산순위 연산자 종류
-------------------------------------------------------1
( )
2
!
~
++
-- *
&
sizeof
3
*
/
%
4
+
딳딳
5
<<
>>
6
<
<=
>
>=
7
==
!=
8
&
9
^
10
|
11
&&
12
||
13
? :
14
=
+=
-=
*=
/=
%=
========================================================
제2절
one =
two =
three
one =
one =
two =
three
three
대입 연산자 (=)
0;
0;
= 0;
two = three = 0;
1;
2;
= 3;
= (two = (one = 1) + 1) + 1;
표 딴딮딱딺 축약형 대입 연산자
일반 연산식 축약형 연산식 설 명
i = i + 2;
i += 2;
땩 의 값을 딲 씩 증가 시킨다딮
x = x - 10;
x -= 10;
땸 의 값을 딱따 씩 감소 시킨다딮
y = y * 5;
y *= 5;
땹 의 값을 딵 의 배수로 증가 시킨다딮
제3절
산술연산자
산술연산자에는 사칙 연산자 딨딫딬 딭딬 딪딬 딯딩 와 나머지 연산자 딨딥딩 가 있다딮
imsi = 5 + 45; // 50
imsi = 12 - 6; // 6
imsi = 76 * 29; // 2204
딳딴
imsi = 66 / 22; // 3
5 % 4
//결과값 : 1 (나머지)
10 % 7
//결과값 : 3 (나머지)
주의사항 딨땃 언어의 경우 딺 시스템마다 다른 결과딩
printf("5.0 / 2.0 = %.1f, %d\n", 5.0 / 2.0, 5.0 / 2.0);
printf("5.0 / 2 = %.1f, %d\n", 5.0 / 2, 5.0 / 2);
printf("5 / 2.0 = %.1f, %d\n", 5 / 2.0, 5 / 2.0);
printf("5. / 2. = %.1f, %d\n", 5. / 2., 5. / 2.);
printf("5 / 2 = %.1f, %d\n", 5 / 2, 5 / 2);
딱 번과 같이 인자 딨딵딮따딯딲딮따딩 에 정확한 소수점을 사용하고 출력 시에는 딥땦 를 사용하면 됨딮
숫자를 나눈 후 발생하는 나머지를 구하는 연산자 정수연산만 가능하며 실수연산 불가
제4절
증가, 감소 연산자
• 증가 연산자 딨딫딫딩딺 변수의 값을 하나 증가 시킴
• 감소 연산자 딨--딩딺 변수의 값을 하나 감소 시킴
• 전치 연산자 딨딫딫땩딬 --땩딩딺 연산자가 인자의 앞에 존재
• 후치 연산자 딨땩딫딫딬 땩--딩딺 연산자가 인자의 뒤에 존재
전치딬 후치 증감 연산자
++i : 전치 증가 연산 (i = i + 1과 같음)
i의 값을 바로 증가 시킴
i++ : 후치 증가 연산
i의 값을 나중에 증가 시킴
--i : 전치 감소 연산 (i = i - 1과 같음)
i의 값을 바로 감소 시킴
i-- : 후치 감소 연산
i의 값을 나중에 감소 시킴
증가연산자의 증가시점
전치 연산의 경우 변수가 할당되기 전에 바로 증가
딳딵
i = 5;
j = ++i; // j에 6이 할당
후치 연산의 경우 변수가 할당된 다음 증가
j = i++; // j에 5가 할당
주의 딺 증감 연산자를 하나 이상 같은 수식에 사용하는 것은 피하라
i =
j = j++
j = i++
j = i--
7;
+ ++i;
+ i++;
+ ++i;
제5절
관계 연산자
------------------------------------관계연산자 내
용
------------------------------------a > b
a가 b보다 크다.
a < b
a가 b보다 작다.
a <= b
a가 b보다 작거나 같다.
a >= b
a가 b보다 크거나 같다.
a == b
a와 b가 같다.
a != b
a와 b가 같지 않다.
------------------------------------땃 에서 따 은 땆땁때땓땅 을 따 이외의 수는 땔땒땕땅 을 의미함 관계 연산자의 결과 값은 딱 아니
면 따 임
if(a > 5) puts("a가 5보다 크다.");
while(1) { puts("forever"); } // 무한루프
if((grade <= 100) && (grade >= 90))
puts("당신은 우수한 성적입니다.");
비교대상의 형 딨땔땹땰땥딩 이 다를 경우
#include <stdio.h>
main()
{
딳딶
int x=1000;
unsigned int y=-1;
if(x>y) printf("x는 y보다 크다.\n");
printf("x=%u, y=%u\n", x, y);
}
제6절
논리 연산자
논리 연산자의 종류
• 논리합 딨||딩딺 두 항 중에 하나라도 참이면 그 결과값이 참
• 논리곱 딨딦딦딩딺 두 항이 모두 참일 때만 그 결과값이 참이 되고 둘 중에 하나라도 거
짓인 항이 있으면 전체 결과값이 거짓
• 논리부정 딨딡딩딺 항의 결과 값을 반대로 만듦
땸
따
따
딱
딱
제7절
땹 논리합
따
따
딱
딱
따
딱
딱
딱
논리곱
따
따
따
딱
논리부정 딨땸딩
딱
딱
따
따
조건 연산자
딳 개의 항 딨 딿 딺 딩 을 이용하므로 삼항 연산자라고도 부름 딻 조건 연산자는 복잡한 식을 표현할
때 실수할 우려가 있으므로 사용을 자제할 것
표현식
result = (expression) ? (value1) : (value2) ;
땥땸땰땲땥땳땳땩땯땮 에서 수식을 검사하고 만약 참이면 바로 뒤에 있는 땶땡땬땵땥딱 의 값을 땲땥땳땵땬땴 에 할
당하고 그렇지 않으면 땶땡땬땵땥딲 를 땲땥땳땵땬땴 에 할당함 딨땶땡땬땵땥 는 수식이나 할당 문도 올 수 있음딩
예제 :
x = y ? 10 : 100;
딳딷
땸 가 땩땮땴 형일 경우 땹 의 값이 따 보다 크면 딱따 이 땘 에 할당되고 그렇지 않으면 딱따따 이 할당됨
x = (y > 10) ? (y + 10) : (y - 10);
땸 가 땩땮땴 형일 경우 땹 가 딱따 보다 크면 땹 딫 딱따 한 결과가 땸 에 할당되고 그렇지 않으면 땹 딭 딱따
한 결과가 땸 에 할당됨
x = (y > 10) ? "OK" : "NO";
땸 가 포인터변수인 경우 땹 가 딱따 보다 크면 땏땋 라는 문자열이 땸 에 할당 딨주소 값이 할당됨딩되
고 그렇지 않으면 땎땏 가 할당됨
제8절
비트연산자
비트연산자의 종류
~ : 1의 보수비트
^ : XOR 비트
| : OR 비트
& : AND
<< : 왼쪽shift
>> : 오른쪽 shift
비트연산자에 의한 연산 예
~ 5 :
~ 0000 0000 0000 0101
=> 1111 1111 1111 1010
5^7 :
0000 0000 0000 0101
^ 0000 0000 0000 0111
=> 1111 1111 1111 1101
같은 위치의 비트가 같으면 1 다르면 0
5|7 :
0000
| 0000
=> 0000
둘 다 0
0000
0000
0000
미면
0000
0000
0000
0 둘
0101
0111
0111
중하나라도 1 이면 1
딳딸
5&7 :
둘 다 1 미면 1 둘 중 하나라도 0 이면 0
imsi = 5; imsi << 2 ;
0000 0000 0000 0101
=> 0000 0000 0001 0100 //왼쪽으로 2bit 이동
제9절
기타연산
• 캐스트 연산자
int a;
float b;
a = 10;
b=a/3;
printf("%f, %f",b, (float)a/3);
• 땳땩땺땥땯땦 연산
sizeof(double)
int a;
sizeof(a);
제 10 절
연습문제
딱딮 매크로 함수에서 다음과 같이 괄호를 생략했을 때와 생략하지 않았을 때의 차이점을
기술하시오딮
#define
#define
MUL(x, y)
MUL(x, y)
x * y
((x) * (y))
딲딮 땳땣땡땮땦딨딩를 이용하여 세 숫자를 받아 들이고 이들의 합과 곱을 출력하시오딮 두 수를
입력 받아 다음과 같이 출력 하시오딮 딨단딬 매크로 함수를 사용한다딩
입력
: 4 6
출력
: 4 * 6 = 24
4 + 6 = 10
딳딹
딳딮 반지름의 값을 입력하면 원의 부피에 대한 결과를 출력하시오딮 딨단딬 매크로 함수를
사용한다딮딩
입력
출력
: 35
: 35 * 35 * 3.14 = 3846.5
딴딮 다음의 공란을 채우시오딮
#include <stdio.h>
#define PRINT(x) (
main()
{
PRINT(5, 7);
PRINT(9, 10);
PRINT(34, 76);
}
)
딵딮 두 수를 입력 받고 다음과 같이 출력하시오딮 딨단딬 더하고 빼고 곱하고 나누는 함수는
매크로 함수를 사용한다딩
입력
: 12 6
출력
: 12 + 6 = 18
12 ? 6 = 6
12 * 6 = 72
12 / 6 = 2
딶딮 생년월일을 입력하면 나이를 출력하는 프로그램을 작성하시오딮 딨단딬 나이를 계산하는
알고리즘은 매크로 함수로 작성한다딮딩
딴따
제5장
제어문
제1절
if ... else 문
기본형
if(조건식) 문장1;
else 문장2;
if()문안에 있는 조건식이 참이면 문장 딱 수행하고 거짓이면 문장 딲 를 수행 딻 하나 이상의 문
장을 수행하기 위해서는 중괄호가 필요함 딻 else 는 없어도 됨
예제 딱딺 한 문장만 수행하는 경우 딨중괄호를 사용하지 않아도 됨딩
if(imsi == 5) puts("FIVE");
if(imsi == 5) puts("right");
예제 딱딺 두 문장 이상 수행하는 경우 딨중괄호 필수딩
if(imsi == 5){
puts("FIVE");
puts("right");
}
1.1
다중 if ∼ else
조건식이 여러개가 있고 조건에 따라서 서로 다른 문장을 수행할 때 이용
if(조건식1) 문장1;
else if(조건식 2) 문장2;
else if(조건식 3) 문장3;
else 문장4;
딴딱
예제 딳 딨학점 출력딩
if((grade >= 90) && (grade <= 100)) puts("A 학점");
else if((grade >= 80) && (grade < 90)) puts("B 학점");
else if((grade >= 70) && (grade < 80)) puts("C 학점");
else puts("F 학점");
제2절
switch
다중 땩땦 ~ 땥땬땳땥 의 효과적인 표현 딻 땳땷땩땴땣땨딨딩의 조건식에서는 실수를 사용할 수 없음
사용법
switch(수식){
case 상수1 :
수행문1;
...
break;
case 상수2 :
수행문2;
...
break;
default :
수행문3;
...
break;
}
예제
switch(operator)
{
case 1 :
puts("1번 case");
break;
case 2 :
puts("2번 case");
break;
default puts("error");
}
딴딲
2.1
주의사항
• 땳땷땩땴땣땨 ~ 땣땡땳땥 에서의 수식과 상수는 정수만이 올 수 있음 딺
땳땷땩땴땣땨딨딩에서의 수식의 결과 값은 정수 딻 부동 소수점이나 문자열은 땳땷땩땴땣땨딨딩의 수식
문에 올 수 없음
switch(5.5), switch(5.0), switch(7.7) (사용될 수 없음)
switch("imsi"), switch("576") (사용될 수 없음)
• 땢땲땥땡땫 문을 조심하지 않으면 논리에러가 발생할 수 있음
switch(result){
case 1: puts("You are a man.");
case 2: puts("You are a woman.");
case 3: puts("Input error.");
}
You are a man.
You are a woman.
Input error.
제3절
while 문
while(조건식){
수행문1;
수행문2;
...
}
땷땨땩땬땥 문은 조건식이 참이면 안에 있는 문장을 반복적으로 수행하고 그렇지 않으면 땷땨땩땬땥 문
밖으로 빠져 나간다딮
간단한 예 딺
i = 1;
while(i <= 10){
printf("%d\n", i);
i++;
}
예제 딺 딱 부터 딱따따 까지 더하기
딴딳
int i, tot=0;
i = 1;
while(i <= 100){
tot += i;
i++;
}
printf("Total = %d\n",tot);
제4절
do ... while 문
do {
수행문1;
수행문2;
...
} while(조건식);
땤땯 문은 땷땨땩땬땥 안의 조건식이 참일때 반복 수행한다딮
예제 딱딺
printf("어떤 메뉴가 있습니까?(종료는 0)\n");
do{
puts("=== menu ===");
puts("1. 짜장면");
puts("2. 짬뽕");
puts("3. 탕수육");
scanf("%d", &num);
} while(num!=0);
문장이 다 수행된 후 마지막에 조건을 체크한다딮 딨땷땨땩땬땥 문이 수행문 보다 먼저 조건
체크를 한다는 점에서 차이가 있다딮딩
#include <stdio.h>
void main()
{
int ii = 1, nn = 5;
double val = 0.0;
while (ii <= nn) { //while loop example:
val += ii;
딴딴
++ii;
}
printf("(1) ii=%d, val=%d\n", ii, val)
ii = 1; nn = 5; val = 0.0;
do { //do-while loop example:
val += ii;
++ii;
} while (ii <= nn);
printf("(2) ii=%d, val=%d\n", ii, val)
}
제5절
for 문
기본형
//괄호안은 수행순서임;
for(초기식(1); 조건식(2); 증감식(4))
{
수행문(3);
...;
}
땦땯땲 문은 조건식이 참일 때 중괄호 안에 있는 문장들을 반복 수행한다딮 땦땯땲 문 처음에 초기식
에 의해 변수를 초기화 하고딬 조건을 체크한후 문장들을 수행한다딮 문장들을 한번 수행한
후 증감식에 의해 변수들을 증가시키거나 감소시킨다딮
예제 딱딺
for(i=1; i<= 100; i++){
printf("%d", i);
if(i % 10 == 0) putchar("\n");
}
쉼표연산자와 for() 예제 딲딺
for(i=0, j=0; i<100 ; i++, j+=2){
printf("i=%d, j=%d\n",i,j);
}
딴딵
5.1
루프의 제어
땦땯땲딬 땷땨땩땬땥딬 땤땯딬 땳땷땩땴땣땨 문에서 break딬 continue 는 반복문의 제어를 이동 시킬 때 사용하며
return 은 함수를 끝낼 때 사용 함딮
• 땣땯땮땴땩땮땵땥딺 반복문의 처음으로 제어권을 넘김
for(i=0; i<10;i++){
...
if (i<j) continue;//처음으로 돌아감;
...
}
예제 딲딺 홀수만 출력하기
for (ii = 0; ii <= 50; ii++) {
if (ii%2 == 0) continue;
printf("%d\n", ii);
}
• 땢땲땥땡땫딺 반복문을 빠져 나감
for(i=0; i<10;i++){
...
if (i<j) break;//루프를 끝냄;
...
}
• 땲땥땴땵땲땮딺 함수의 수행을 끝내고 호출한 쪽으로 제어권을 넘김
• 땧땯땴땯딺 잘 사용하지 않지만 종종 사용되는 것을 볼 수 있음 딻 땧땯땴땯 다음에 옮겨갈 장소
딨땬땡땢땥땬딩 를 적음 딻 땬땡땢땥땬 옆은 세미콜론이 아니라 콜론임에 유의
goto label;
...
label:
문장;
http://www.acm.uiuc.edu/webmonkeys/book/c_guide/
딴딶
제6절
연습문제
딱딮 딱 부터 딱따따따 까지의 합을 구하는 프로그램을 작성하시오딮
딲딮 구구단을 출력하는 프로그램을 작성하시오딮 딨딲 단부터 딹 단까지딩
출력
: 2 x 1 = 2
2 x 2 = 4
딳딮 국어딬 영어딬 수학 점수를 입력 받고 총점과 평균을 구하는 프로그램을 작성하시오딮
입력
: 68 86 37
출력
: 국어 영어 수학 총점 평균
===================
68
86
37
191 63
딴딮 문자열 딨영어 알파벳딩 을 입력 받고 문자가 출현한 횟수를 구하는 프로그램을 작성하
시오딮
입력
출력
: oaudfanwetrnlrgeoparhaeo
: [a] : 3 번 출현
[b] : 0 번 출현
...
딴딷
딴딸
제6장
배열과 포인터
제1절
1.1
배열
배열의 특징
• 배열은 동일한 자료형을 가지는 집합체임
반드시 자료형이 같아야 함 딻 배열을 정의할 때 앞의 두 요소는 땩땮땴 형이고 뒤의 딵 요
소는 땣땨땡땲 형이라는 식으로 정의할 수 없음
• 배열은 연속된 메모리 공간을 가짐
연속되어 저장되지 않으면 땃 의 포인터 연산이 불가능함
• 배열을 이용하게 되면 많은 수의 변수를 한꺼번에 정의할 수 있으며 관리하기도 편함
• 여러 개의 변수를 반복문으로 처리하는 것은 거의 불가능하지만 배열을 이용하게 되
면 어렵지 않게 처리할 수 있게 됨
• 배열의 표현법이나 사용법은 대단히 쉬우나 메모리적으로 어떻게 처리되는지 확실히
모르면 포인터와 결합했을 때 난해해 짐
1.2
배열의 필요성
딨땅땘딩 학급의 성적 관리 딨딴따 명딩
학급의 학생 이름을 모두 나열한다.
학생 이름 옆에 성적을 기입한다.
학생 별 총점, 평균을 구한다.
국어, 영어, 수학의 학급 전체 총점, 평균을 구한다.
학급 전체의 총점과 평균을 구한다.
딴딹
배열의 필요성
• 변수 사용 딺
딴따 명분의 변수가 필요함 각 변수의 이름은 달라야 얌
int
a, b, c, d, e, ....
total = a + b + c + d + e + ...
ave = total / 40;
• 배열 사용 딺
배열을 사용함으로써 딴따 명분의 변수 이름이 같을 필요가 없음 딻 변수의 이름이 같지
않음으로 관리하기가 편해짐
int student[40];
for(i = 0;i < 40;i++)
total += student[i];
ave = total / 40;
제2절
포인터
• 간단히 말해서 포인터는 메모리의 주소를 나타낸다딮 친구 집을 찾아가기 위해서는 주
소가 필요한 것처럼 시스템에서도 특정한 값을 찾기 위해서는 주소가 필요함
• 실생활에서의 주소는 시딬 도딬 군 등으로 나누지만 통상적인 딳딲땢땩땴 컴퓨터 시스템에서
는 딴 바이트로 표기한다딮
• 포인터를 다루기 위해서는 먼저 포인터 변수를 정의해야 하고 여기서 포인터 변수란
포인터를 저장할 수 있는 변수를 뜻함
• 포인터 변수에는 포인터 딨주소딬 번지딩 값 이외에는 절대 들어 갈 수 없음
• 포인터 변수 정의 예 딺
int *int_p;
char *char_p;
float *float_p;
• 잘못된 포인터 변수 사용 예 딺
int
*int_p;
int_p = 48;
int_p = ’x’;
딵따
2.1
번지 연산자 (&, *)
&: 번지연산자
*: 역 참조 연산자 (포인터 변수 정의 시에도 사용)
int *imsip;
int temp = 5;
딦 번지 연산자는 변수 앞에 사용하여 그 변수가 저장된 메모리의 위치를 의미 딦땴땥땭땰딺
땴땥땭땰 가 저장된 곳의 위치
딪 번지 연산자는 포인터 변수 앞에 사용하여 포인터 변수에 저장된 번지 값을 참조 딻
딪땩땭땳땩땰딺 땩땭땳땩땰 안에 저장된 주소 값을 참조로 하는 값 딨주소로 참조되는 값은 정수나 문자
이기도 하지만 주소 값이 될 수도 있음딩
2.2
포인터의 형
포인터는 주소 값이기 때문에 연산을 하게 되면 주소 값이 참조하는 값을 가져와야 함딮 포
인터의 형은 주소 값에서 얼마만큼 읽어 올지를 지정한다딮
short *shortp; //shortp가 가리키는 곳에서부터 2바이트를 읽음;
int *intp; //intp가 가리키는 곳에서 4바이트를 읽어오게 됨
2.3
배열과 포인터
배열명은 주소 값이므로 땩땭땳땩땰 딽 딦땴땥땭땰딻 가 아니라 땩땭땳땩땰 딽 땴땥땭땰 로 초기화가 가능함 배
열명은 첫 번째 배열요소의 주소 값 임
포인터 딫 정수의 의미
*imsip // 나는 A 아파트 102동 705호에 산다.
*(imsip + 1) // 나의 친구는 내 옆집에 산다.
*(imsip + 2) // 나의 또 다른 친구는 내 옆집의 옆집 산다.
포인터 연산의 딧딪딧 하나는 딧땛땝딧 하나와 완전히 일치함 땩땭땳땩땰땛딱땝 과 딪딨땩땭땳땩땰 딫 딱딩 은 같은
연산
배열방식 딨땩땭땳땩땰땛땩땝딩 보다는 포인터 연산방식 딨딪딨땩땭땳땩땰 딫 땩딩딩 을 사용하는 것이 좋음
다음과 같을 때 땩땭땳땩땰 를 초기화 하는 방식은 두 가지로 표현될 수 있음
int temp[3] = { 7, 20, 15 };
int *imsip;
imsip 초기화 방법
imsip = temp;
imsip = &temp[0];
딵딱
딱 차원 배열 포인터 정의와 할당
int temp[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int *imsip;
imsip = temp;
제3절
실습
학생들의 성적을 입력받아 기초통계량 및 줄기딭잎 그림을 그리는 프로그램을 작성해 보자딮
http://datamining.dongguk.ac.kr/lectures/spring2008/programming/c/test/BasicStat.
txt
딵딲
제7장
메모리 할당과 해제
malloc()
calloc()
realloc()
제1절
메모리 할당
메모리의 안전한 영역을 확보하고 이를 알려줌
메모리 영역
• 텍스트 영역 딨땔땥땸땴 땳땥땧땭땥땮땴딩 딺 땃땐땕 에 의해 실행되는 머신 코드들이 있는 영역딮땒땥땡땤
땏땮땬땹
• 초기화된 데이터 영역 딨땉땮땩땴땡땬땩땺땥땤 땤땡땴땡 땳땥땧땭땥땮땴딩 딺 땤땡땴땡 땳땥땧땭땥땮땴 라 불리는 영역이
며딬 초기화된 외부 변수 땳땴땡땴땩땣 변수등이 저장되는 영역입니다딮 보통 땔땥땸땴 땳땥땧땭땥땮땴 딫
땩땮땩땴땩땡땬땩땺땥땤 땤땡땴땡 영역을 합쳐서 프로그램이라고 함
예딩 땳땴땡땴땩땣 땩땮땴 땡 딽 딱딻
• 비 초기화된 데이터 영역 딨땕땮땩땮땩땴땡땬땩땺땥땤 땤땡땴땡 땳땥땧땭땥땮땴딩 딺 땢땳땳 땳땥땧땭땥땮땴 라고 불리며딬 이
영역은 프로그램이 실행될 때 따 이나 땎땕때때 땐땯땩땮땴땥땲 로 초기화
예딩 땳땴땡땴땩땣 땩땮땴 땡딻
• 스택 (Stack)딺 자동 변수들이 저장되는 곳이고딬 함수가 호출될 때 함수 안의 자동변수
등이 저장되는 곳딮 함수가 실행되는 동안에만 존재하며 함수의 실행이 종료되면 그
변수들도 사라짐
• 힙 (Heap) 딺 동적 메모리 할당을 할 경우 땈땥땡땰 영역에 할당이 됨딮 땈땥땡땰 영역은 땵땮땩땮땩딭
땴땩땡땬땺땥땤 땤땡땴땡 영역의 땴땯땰 과 땳땴땡땣땫 영역의 땢땯땴땴땯땭 부분에 위치합니다딮
딵딳
• 정적 메모리 할당 딺 프로그램이 실행되기 전에 메모리 할당딮 메모리의 증감이 불가능
함
• 동적 메모리 할당딺 프로그램이 실행 된 후 메모리 할당딮 프로그램이 실행된 후 메모
리의 증감이 가능
딪딪 동적 메모리는 일반변수로는 접근할 수 없으며 항상 포인터 변수를 통해서 접근해야
함
동적 메모리 할당의 장딬 단점
• 장점 딺 특히 다중사용자용 프로그램에서 제한된 자원 딨땭땥땭땯땲땹딩 에 대한 효율적인 이
용이 가능하다딮
• 단점 딺 동적 메모리 할당은 실행될 때 메모리가 할당되는 방식이기 때문에 약간의 시
간지체가 필연적으로 발생
구현이 복잡하다 딨땍땅땍땏땒땙 때땅땁땋 에 유의딩딮
1.1
malloc()
동적 메모리를 할당
딵딴
void
*malloc(size_t size); // #include <stdlib.h>
void형 포인터를 리턴
캐스트 연산자를 이용하여 형 변환
size_t는 일반적으로 unsigned long이나 long로 선언되어 있기 때문에
부족하지 않은 메모리 영역을 할당 받을 수 있음
문자열 포인터 변수에 메모리 할당
void func()
{
int one;
char dim[1024];
char *imsip;
imsip = (char *)malloc(100);
...
}
땩땭땳땩땰 는 포인터 변수이므로 땭땡땬땬땯땣딨딩에 의해서 리턴 되는 주소 값을 받을 수 있음 모두
딱따따 바이트의 안전한 영역을 할당 받음 조심하여야 할 것은 땦땵땮땣딨딩 함수에서 땭땡땬땬땯땣딨딩에 의
해 생성된 딱따따 바이트는 프로그램이 끝나기 전까지는 절대 해제되지 않는 다는 것임 땦땵땮땣딨딩라
는 함수가 끝나면 자동으로 메모리 해제가 될 것 같지만 땭땡땬땬땯땣딨딩에 의해서 생성된 메모리
영역은 강제로 땦땲땥땥딨딩와 같은 메모리 해제 함수를 사용하지 않으면 절대 해제 될 수 없음
땯땮땥딬 땤땩땭 은 땦땵땮땣딨딩가 끝나면 메모리가 자동으로 해제됨
구조체 포인터 변수에 메모리 할당
struct grade_t {
char name[20];
int kor;
int eng;
int mat;
};
struct grade_t *imsi;
imsi = (struct grade_t *)malloc(sizeof(struct grade_t));
1.2
calloc()
함수의 원형
딵딵
#include <stdlib.h>
void *calloc(size_t count, size_t size);
땭땡땬땬땯땣딨딩과 땣땡땬땬땯땣딨딩의 차이
땣땡땬땬땯땣딨딩도 메모리를 동적으로 할당해주는 함수인데 땭땡땬땬땯땣딨딩과 달리 할당된 메모리 영
역을 깨끗이 따 으로 초기화 함
땣땡땬땬땯땣딨딩을 사용하면 초기화하는 시간이 발생하게 되고 초기화 해야 할 메모리의 영역이
크다면 다른 함수로의 전환이 필요하게 됨
일반적으로 다음과 같이 사용함
char *imsip;
imsip = (char *)calloc(100, sizeof(char));
1.3
realloc
void *realloc(void *ptr, size_t size);
이미 할당된 메모리 영역을 새로운 크기로 변경하는 함수 딻 일반적으로 할당된 메모리의
크기를 줄이기 보다는 늘이는데 사용됨 딻 딱따 바이트의 메모리를 할당하여 처리하던 중 나중
에 딱딵 바이트로 늘리고 싶다면 이전의 딱따 바이트 내용은 삭제하지 않은 채 딱딵 바이트로 늘
려야 하는데 이 때 사용되는 함수가 땲땥땡땬땬땯땣딨딩임 딻
땲땥땡땬땬땯땣딨딩이 성공하면 새로이 할당된 메모리의 주소가 리턴 되며 실패하면 땎땕때때 을 리턴
char *imsip;
imsip = (char *)malloc(10);
...
bigger_imsip = (char *)realloc(imsip, 15);
제2절
메모리 해제
함수의 원형
void free(void *ptr);
구조체 메모리 해제
struct grade_t *student;
student = (struct grade_t *)malloc(sizeof(struct grade_t));
...
딵딶
free(student);
free(student->name);
(X)
free(student->name);
free(student); (O)
딵딷
딵딸
제8장
구조체 (structure)
구조체란 다른 형 딨땔땹땰땥딩 을 가질 수 있는 하나 이상의 변수들의 모임이며 편의상 단일 명
칭을 사용함 배열은 개개의 배열 요소들이 모두 같은 형을 가지는데 반해서 구조체는 개
개의 요소들이 모두 다른 형을 가질 수 있음
왜 구조체를 사용하는가를 이해하기 위해 다음 주소록을 작성하는 예를 살펴보자딮
예 : 주소록
한 사람에 대한 주소록을 만들기 위해서 필요한 여러개의 항목들 딨이를테면딬 이름딬 회사명딬
주소딬 전화번호딬 생일등딮딮딮딩 이 있다딮 주소록과 관련된 항목들에 대한 연산을 위해서는 아래
와 같은 변수들에 대한 선언이 필요하다딮
char
char
char
char
char
name[20];
//이름
company[20]; //회사명
addr[50];
//주소
phone[15]; //전화번호
birthday[11];
//생일
strcpy()함수를 이용하여 위에서 선언한 변수들에 실제 값을 넣을 수 있다딮
strcpy(name, "홍길동");
strcpy(company, "동국대학교 정보통계학과");
strcpy(addr, "경주시 석장동");
strcpy(phone, "010-333-4444");
strcpy(birthday, "1980-03-21");
주소록에는 여러사람의 정보를 포함해야 되며 이들을 저장하기 위해서는 다음과 같은
딲 차원 배열을 이용할 수 있다딮
char name[10]][20], company[10][20], addr[10][50];
chat phone[10][15], birthday[10][11];
딵딹
물론 위와 같은 다중 주소록에 여러 명의 정보를 저장하기 위해서는 strcpy()를 이용한다딮
strcpy(name[0], "홍길동");
strcpy(company[0], "통계학과");
위의 주소록 예에서 보듯이 복잡한 자료의 처리를 위해서는 딲 차원배열과 같은 많은 변
수를 선언해야 하고 이를 이용한 연산을 필요로 한다딮
구조체 딨땳땴땲땵땣땴땵땲땥딩 는 관련된 여러 가지의 데이터형을 하나의 그룹으로 묶어 마치 하나
의 변수처럼 다룰 수 있게 하는 것으로서 다음과 같은 장점이 있다딮
• 연관된 데이터 요소를 조직
• 파일 입출력을 단순화
• 함수 인수의 수를 최소화
• 메모리 할당에 특별한 순서를 줄 수 있다딮
• 프로그램을 더욱 읽기 쉽게 한다딮
제1절
1.1
구조체의 구조, 선언, 초기화
구조체 선언
(1) struct 구조체-TAG {...};
// 구조체 템플리트
struct 구조체-TAG 구조체변수-리스트;// 구조체 변수
(2) struct 구조체-TAG {...} 구조체변수; // 구조체 템플리트와 변수
위에서 배열로 선언했던 주소록을 구조체를 이용하여 다시 선언해 보자딮
딶따
• 땳땴땲땵땣땴 구조체딭땔땁땇 {딮딮딮}딻
struct address_t{
char name[20];
....
char birthday[11];
};
struct address_t
address;
• 땳땴땲땵땣땴 구조체딭땔땁땇 {딮딮딮} 구조체변수딭리스트 딻
struct address_t{
char name[20];
....
char birthday[11];
} address;
• 땴땹땰땥땤땥땦 를 사용한 구조체 선언 딺 땴땹땰땥땤땥땦 는 구조체를 하나의 형으로 정의할 수 있음
typedef struct address_t{
char name[20];
....
char birthday[11];
}ADDRESS;
ADDRESS
Address;
1.2
구조체의 멤버참조 및 복사
구조체의 멤버변수를 참조하기 위해서는 구조체 연산자인 땠딮딧 를 이용한다딮
//구조체변수.멤버변수
address.name;
구조체 멤버를 다른 구조체의 멤버에 복사하기 위해서는 간단히 구조체변수를 대입하면 된
다딮
struct grade_t
one = two;
one, two;
딶딱
위의 코드는 아래와 같이 각 멤버변수를 복사하는 것과 동일한 효과를 갖는다딮
strcpy(address.name, address.name);//문자열
address.phone = address.phone;
//숫자형
1.3
구조체 초기화
• 구조체의 초기화 딺
//구조체 tag-name을 이용한 초기화:
struct tag-name ＝ {초기화 목록};
//구조체 선언과 동시에 변수의 값을 초기화
struct tag-name {
member-list;
...
} 구조체변수＝{초기화 목록};
struct score_t {
char name[20];
float math;
float stat;
} personal = {"J. Kim", 82.5, 90.4};
• 초기화 시 주의할 점
– 구조체 템플리트 선언문에 직접 멤버를 초기화할 수 없다딮
– 데이터형이 다를 경우
– 초기화를 하지 않을 경우
– 초기값이 땭땥땭땢땥땲 수보다 작을 경우
1.4
매개변수가 구조체인 함수
struct grade_t func(struct grade_t student)
{
...
return student;
}
딶딲
제2절
구조체 배열과 구조체 포인터
아래와 같이 구조체가 정의되고 변수가 선언되었다고 하자딮
struct address {
char
name[20];
char
birthday[15];
char
home_address[50];
char
phone_number[20];
};
구조체 배열 및 포인터의 선언
struct address
my_address[10];
//배열;
struct address
*my_address;
//포인터;
pAddr = (struct address_t *)malloc(sizeof(address_t));
구조체를 참조 딨땡땣땣땥땳땳딩 하기 위해 포인터를 사용할 수 있으며
2.1
구조체 포인터에 의한 멤버참조
• 구조체 변수를 바로 정의한 경우 멤버를 참조할 때
my_address[0].name
my_address[1].name
• 구조체 변수를 포인터 변수로 정의하여 참조할 때
(*my_address).name
my_address->name
2.2
구조체 포인터의 메모리 할당
struct grade_t{
char
*name;
int
kor;
int
eng;
int
mat;
};
struct grade_t *student;
student = (struct grade_t *)malloc(sizeof(struct grade_t));
student->name = (char *)malloc(20);
딶딳
2.3
구조체의 크기
struct grade_t imsi_grade;
printf("The struct grade_t size is %d.\n", sizeof(struct grade_t));
The struct grade_t size is 32.
제3절
공용체
공용체는 어느 하나의 기억 영역을 확보하여 여러 데이터형을 공유하는 기능을 담당하며
다음과 같이 선언한다딮
union tag-name
{
member list;
...
} name-list;
예를들면 아래와 같다딮
union share
{
int i;
float j;
};
union share share_i, share_ j;
공용체를 이용한 시간급과 월급별 사원 급여 계산
#include <stdio.h>
#define MAXLEN 100
#define MAX 100
struct salary {
char name[MAXLEN];
long salary;
};
struct hourly {
char name[MAXLEN];
int salary;
int rate;
딶딴
};
union s_or_h {
struct salary sal_emp;
struct hourly hr_emp;
};
main( )
{
char instr[10];
int count;
union s_or_h employee[MAX];
char payroll_type[MAX]; /* 시간급과 월급을 구별하는 flag */
printf("시간급은 h, 월급은 s를 입력:\n");
gets(instr);
payroll_type[count] ＝ instr[0];
printf("이름을 입력하세요? \n");
gets(instr);
if (payroll_type[count] == ’h’)
strcpy(employee[count].hr_emp.name, instr);
/* 입력된 이름을 시간급에 저장 */
else
strcpy(employee[count].sal_emp.name, instr);
/* 입력된 이름을 월급에 저장 */
}
딶딵
딶딶
제9장
함수
프로그램 내에서 어떤 특정한 작업을 전담하게끔 독립적으로 만들어지는 하나의 단위로 일
종의 규격화된 서브루틴 딨땳땵땢땲땯땵땴땩땮땥딩 이다딮
기능 딺
• 커다란 프로그램을 작업 별로 분할 제작
• 땔땯땰딭땤땯땷땮 방식의 모듈화된 프로그램 설계
• 알아야 할 필요가 없는 세세한 작업이나 연산 등을 함수의 내부에 숨길 수 있음
• 체계적이고 간결한 프로그램을 제작할 수 있음
• 프로그램을 이해하고 수정하기 용이함
종류 딺
• 기본적으로 제공하는 표준 라이브러리 함수
• 사용자 정의 함수
특징 딺
• 모듈화를 가능하게 해준다딮
• 정보 은닉을 제공한다딮
제1절
함수의 구조
return-type function-name(args){
함수 본체...
return xxx;
}
딶딷
• 땲땥땴땵땲땮딭땴땹땰땥딺 반환값의 자료형
• 땦땵땮땣땴땩땯땮딭땮땡땭땥딺 함수의 이름 딨변수명의 규칙과 동일딩
• 땡땲땧땳딺 호출된 함수로 넘겨주는 인자
예제 딺
#include <stdio.h>
int power( int n, int m);
void main()
{
int i;
for ( i = 0; i <= 10; i++ )
printf("%5d\n", power(2,i));
}
int power( int n, int m)
{
int i, result = 1;
for ( i = 1; i <= m; i++)
result *= n;
return result;
}
1.1
매개변수
함수의 호출 시에 다른 함수로 전달되는 변수로 실 매개변수와 형식 매개 변수로 나뉨
1.2
함수를 작성하는 순서
딱딮 함수의 이름을 정한다딮
mean()
딲딮 매개변수 및 리턴 값을 결정한다딮
double mean(double *x, double *y, int nobs)
딳딮 함수의 본체를 작성한다딮
딶딸
double mean(double *x, int nobs)
{
double meanx=0;
int i;
for(i=0;i<nobs;i++) meanx += x[i];
mean /= nobs;
return(mean);
}
딴딮 작성한 함수본체를 main() 위에 둘 것인지 아래에 둘 것인지 결정한다딮
• 함수본체를 main()의 아래에 둔다면 main()에 함수선언 필요
• 함수본체를 main()의 위에 둔다면 main()에 함수선언을 할 필요가 없음
딵딮 땭땡땩땮딨딩에서 작성한 함수본체를 호출한다딮
xbar = mean(x, nobs);
제2절
함수의 호출
double sum(double x, double y)
int sum(double x, double y, double *out)
2.1
값에 의한 호출 (Call by Value)
int main()
{
int nn = 3, pp = 3;
double retVal = power2(2.0, 3);
printf("Val = %g\n", retVal);
return 0;
}
double power2 (double xx, int nn)
{
double retVal = 1.0;
for ( ; nn > 0; --nn) {
retVal = retVal * xx;
}
return retVal;
딶딹
}
• 매개변수는 실 매개 변수와 형식 매개 변수로 나뉨
• 호출하는 쪽의 인자를 실 매개 변수라 하고 호출 당하는 쪽의 매개 변수를 형식 매개
변수라 함
• 실 매개변수의 값을 형식 매개 변수에 전달할 때 복사되어 전달됨
• 많은 양의 자료를 전달할 때 메모리나 시간이 많이 소모됨
2.2
참조에 의한 호출 (Call by Reference)
int main()
{
int nn = 3;
double xx = 2.0, retVal;
power3(xx, nn, &retVal);
printf("%g^%d = %g\n", xx, nn, retVal);
return 0;
}
void power3 (double xx, int nn, double *retVal){
for (*retVal = 1.0; nn > 0; --nn){
(*retVal) = (*retVal) * xx;
}
}
• 값에 의한 호출 ⇒ 복사
• 참조에 의한 호출 ⇒ 참조 딨주소딬 포인터딩
• 실 매개변수의 값이 형식 매개변수에 전달될 때 값이 복사되어 전달되지 않고 값이
저장된 주소 값이 전달 됨
• 주소 값을 전달 받기 때문에 전달 받은 매개변수 딨인자딩 를 수정하면 실 매개변수도
수정됨
딷따
제 10 장
File Handling
제1절
외부파일의 입출력
• 땡 딌땬땥 땰땯땩땮땴땥땲딺
FILE *in = NULL, *out = NULL;
• 파일 열기 딺
in = fopen("in.txt", "r");
out = fopen("out.txt", "w");
out = fopen(test_out, "a");
딢땲딢딺 땲땥땡땤 땭땯땤땥딬 딢땷딢딺 딨땯땶땥땲딭딩땷땲땩땴땥 땭땯땤땥딬 딢땡딢딺 땡땰땰땥땮땤 땭땯땤땥
• 파일 닫기 딺
fclose(in);
fclose(out);
• 열린파일에서 자료읽기 딺
float tmp;
fscanf(in, "%f", &tmp); // &tmp대신 tmp를 쓰면 오류발생
• 버퍼의 내용을 파일에 쓰기 딺
fprintf(out, "%f", tmp);
딷딱
예제 :
#define SMALL_LEN 5
int main (int argc, char **argv)
{
int ii;
FILE *in = NULL, *out = NULL;
float tmp;
double dval_arr[SMALL_LEN];
in = fopen("in.txt", "r");
for (ii = 0; ii < SMALL_LEN; ++ii) {
fscanf(in, "%f", &tmp);
dval_arr[ii] = tmp;
}
fclose(in);
out = fopen("out.txt", "w");
for (ii = 0; ii < SMALL_LEN; ++ii)
fprintf(out, "%g\n", dval_arr[ii]);
fclose(out);
return 0;
}
• 특수한 파일 포인터 딨땳땰땥땣땩땡땬 땆땉때땅 땰땯땩땮땴땥땲땳딩딺
stdin
stdout
stderr
• 땴땨땥땳땥 땡땲땥 땡땬땷땡땹땳 땯땰땥땮딺 땳땴땤땩땮딬 땩땮 딢땲딢 땭땯땤땥 땡땮땤 땳땴땤땯땵땴딬 땳땴땤땥땲땲 땩땮 딢땷딢 땭땯땤땥
• 땩땳 땴땨땥땲땥 땡 땤땩딋땥땲땥땮땣땥 땢땥땴땷땥땥땮 땴땨땥 땴땷땯 땳땴땡땴땥땭땥땮땴땳딿
float tmp;
scanf("%f", &tmp);
fscanf(stdin, "%f", &tmp);
printf("%f", tmp);
fprintf(stdout, "%f", tmp);
딷딲
1.1
fgets( )
땎땥땷 땬땩땮땥딨\땮딩딬 파일의 끝딬 땮딭딱 개의 문자를 읽을 때까지 데이터를 읽는다딮
char *fgets(char *buffer, int n, FILE *fp);
char *buffer: 데이터를 저장할 버퍼에 대한 포인터
int n: 버퍼 크기(바이트수)
FILE *fp：읽을 파일에 대한 파일 포인터
반환 값
－성공: 버퍼에 대한 포인터
－실패: NULL 포인터
1. 어떤 데이터를 읽음이 없이 파일의 끝(EOF)을 만났을 때
2. 오류 발생시(예: 파일이 열리지 않았을 때)
1.2
fgetc(). getc()
두 함수는 파일 포인터 땦땰 에 의해서 지정된 파일로부터 문자 단위로 입력을 받는다딮
int fgetc(FILE *fp);
int getc(FILE *fp);
fp: 입력 파일에 대한 파일 포인터
반환값
－성공: 입력 문자를 반환
－실패: EOF 문자를 반환
1.3
파일의 마지막을 찾는 방법
while ((c＝fgetc(fp)) !== EOF)
int *feof (FILE *fp)
반환값
파일의 끝: 0이 아닌 값
파일의 끝이 아닌 경우: 0을 반환
1.4
sprintf(sscanf )
버퍼에 문자열로 출 딨입딩 력하기 위한 함수
int ival = 1;
double dval = 1.11;
딷딳
char *str1 = "This is ", str2[MAX_WORD_LEN];
sprintf(str2, "%s%d", str1, ival);
printf("%s\n", str2);
sprintf(str2, "%s%g", str1, dval);
printf("%s\n", str2);
위 프로그램의 결과는 아래와 같다딮
This is 1
This is 1.11
딷딴
제 II 편
R 프로그래밍
딷딵
제 11 장
서언
본 저작은 땒 을 처음으로 배우려고 하는 사람들을 위한 것이다딮 따라서 땒 이 어떻게 동작
하는지를 알리는 것이 본 저작의 주 내용이 될 것이다딮 땒 에서 제공하는 여러가지 기능을
사용하려면딬 처음에 몇가지의 개념들을 이해할 필요가 있는데딬 본서에서는 독자가 이해하기
쉽도록 그 개념들에 대하여 설명할 것이다딮
땒 을 통계분석 및 그래픽스을 지원하기 위하여 땒땯땳땳 땉땨땡땫땡 과 땒땯땢땥땲땴 땇땥땮땴땬땥땭땡땮 이 개
발하였고딬 땁땔딦땔 땂땥땬땬 때땡땢 에서 만든 땓 언어에서 유래된 것으로 소프트웨어이면서 프로그
래밍언어이다딮 땓 언어에서 유래된 또 다른 소프트웨어로는 땉땮땳땩땧땨땴땦땵땬 에서 상업용으로 만든
만든 땓딭땐때땕땓1 가 있다딮 땒 과 땓 는 소프트웨어 디자인 측면에서 몇가지 차별성이 있는데딬 이
에 대하여는 땉땨땡땫땡 딦 땇땥땮땴땬땥땭땡땮 딨딱딹딹딶딩2 의 논문 혹은 땒딭땆땁땑3 를 참조하기 바란다딮
땒 은 땇땎땕 땇땥땮땥땲땡땬 땐땵땢땬땩땣 라이센스4 에 따라 자유롭게 사용과 배포가 가능하며딬 현재 땒
의 개발과 배포는 몇명의 통계학자로 구성된 땒 땄땥땶땥땬땯땰땭땥땮땴 땃땯땲땥 땔땥땡땭 이 주도하고 있다딮
땒 은 땃 언어와 땆땯땲땴땲땡땮 으로 이루어진 땳땯땵땲땣땥 코드 혹은 땗땩땮땤땯땷땳딬 때땩땮땵땸딬 그리고 땍땡땣땩땮땴땯땳땨
용으로 만들어진 바이너리 코드로 배포가 되고 있고딬 땃땯땭땰땲땥땨땥땮땳땩땶땥 땒 땁땲땣땨땩땶땥 땎땥땴땷땯땲땫
딨땃땒땁땎딩 인터넷사이트인 http://cran.r-project.org/ 에서 구할 수 있다딮
땒 은 통계분석뿐만 아니라 그래픽을 위하여 많은 함수를 제공하는데딬 이들 그래픽 함
수를 통해서 얻어진 이미지는 다양한 형태 딨땪땰땧딬 땰땮땧딬 땢땭땰딬 땰땳딬 땰땤땦딬 땥땭땦딬 땰땩땣땴땥땸딬 땸딌땧딩 로
변환하여 사용할 수 있다딮 통계분석에 관련된 함수는 스크린에 분석 결과를 보여주기도 하
고 결과를 오브젝트의 형태 혹은 파일로 저장할 수 있으며딬 이와 연결된 분석에 사용할 수
도 있다딮 땒 의 프로그래밍 언어의 기능은 사용자가 땬땯땯땰 같은 기능을 사용하여 여러개의 자
료를 연속적으로 분석하거나딬 서로 다른 분석을 위해 작성한 프로그램들을 모아서 복잡한
분석에 이용할 수 있도록 한다딮 땓 언어들은 거의 대부분 땒 에서 동작하므로 땒 사용자들은
1
http://www.insightful.com/products/splus/default.asp
Ihaka R. and Gentleman R. 1996. R: a language for data analysis and graphics. Journal of Computational and Graphical Statistics 5: 299–314.
3
http://cran.r-project.org/doc/FAQ/R-FAQ.html
4
http://www.gnu.org/
2
딷딷
인터넷상에서 구할 수 있는 많은 땓 코드5 들을 구하여 땒 에서 직접 수행할 수도 있다딮
땒 을 처음 접할 경우 땒 을 읽히는 데 다소 어렵다고 느껴질 수도 있지만 땒 의 강점은 다
른 통계소프트웨어와 달리 매우 유연한 소프트웨어로 알려져 있다딮 한 예로 땓땁땓 나 땓땐땓땓
와 같은 전통적인 통계분석소프트웨어들이 분석결과를 화면에 출력해 주는 것과 달리 땒 은
결과를 오브젝트 형태로도 저장하여 주므로 화면에 출력된 결과 없이 이 오브젝트를 가지고
다른 분석을 하는데 유용하게 활용할 수 있다딮 땒 초보자들은 이 점 때문에 놀라는 경우가
간혹 있지만 이런 특징은 매우 유용하며딬 실제로 유저들은 결과물 중에서 자신이 관심이
있는 부분만 선택하여 볼 수도 있다딮 예를들어딬 딲따 개의 회귀분석모형을 만들어 회귀계수를
비교해 보고자 한다면 회귀분석의 결과들 중회귀계수만을 선택하여 출력하면 된다딮 다른
전통적인 분석소프트웨어에서는 이러한 결과만을 출력하는 것이 복잡하거나 어렵다딮
5
http://stat.cmu.edu/S/
딷딸
제 12 장
Download & Install the R system
그림 딱딲딮딱딺 땒 땨땯땭땥땰땡땧땥
• 땄땯땷땮땬땯땡땤 땴땨땥 땒 땳땹땳땴땥땭 땦땲땯땭 http://www.r-project.org/딮
• 땆땩땧땵땲땥 딱 의 좌측에 있는 땃땒땁땎 을 클릭
• 땆땩땧땵땲땥 딲딭딨딱딩 의 우측에 다운로드를 위한 땍땩땲땲땯땲 사이트 중에서 하나를 선택
• 땆땩땧땵땲땥 딲딭딨딲딩 의 우측에서 땏땓 를 선택 딨땗땩땮땤땯땷땳딬 때땩땮땵땸딩
• 땆땩땧땵땲땥 딲딭딨딳딩 의 우측에서 딨땂땡땳땥딬 땣땯땮땴땲땩땢딩 중 택일딬 처음인 경우는 땂땡땳땥 를 선택함
• 땆땩땧땵땲땥 딲딭딨딴딩 의 우측에서 가장 최근버전을 다운로드 한다딮 통상적으로 윈도우버젼인
셋업프로그램은 R-버전-win32.exe 라는 명칭으로 되어 있다딮
• 다운로드된 파일을 실행하면 땗땩땮땤땯땷땳 에 땒 이 설치된다딮
딷딹
그림 딱딲딮딲딺 땒 땩땮땳땴땡땬땬땡땴땩땯땮
제1절
딨딱딩
딨딲딩
딨딳딩
딨딴딩
Rgui
땒 땳땹땳땴땥땭 의 설치가 끝나면 윈도우즈의 바탕화면에 땒땧땵땩 를 실행할 수 있는 아이콘 딨땓땨땯땲땴딭
땣땵땴딩 이 생기는데딬 이를 클릭하면 땒 이 구동이되면서 땆땩땧땵땲땥 딱딲딮딳 와 같은 윈도가 생긴다딮 이
를 땒딭땧땵땩 라고 부른다딮
제2절
Download & Install the Package
땒 시스템에는 기본적으로 설치된 땰땡땣땫땡땧땥 들이 있다딮 이들 기본패키지를 확인하려면 땒딭땧땵땩
에서 search()명령을 실행하면 된다딮
> search()
[1] ".GlobalEnv"
"package:stats"
[4] "package:grDevices" "package:utils"
[7] "package:methods"
"Autoloads"
"package:graphics"
"package:datasets"
"package:base"
이들 패키지들이 설치된 땰땡땴땨 를 확인하는 명령 딨함수딩1 는 아래와 같다딮
> searchpaths()
[1] ".GlobalEnv"
1
명령과 함수를 혼용하여 사용하는 데 이후로는 함수라고 부르겠다
딸따
그림 딱딲딮딳딺 땒땧땵땩
[2]
[3]
[4]
[5]
[6]
[7]
[8]
[9]
"C:/PROGRA~1/R/R-25~1.1/library/stats"
"C:/PROGRA~1/R/R-25~1.1/library/graphics"
"C:/PROGRA~1/R/R-25~1.1/library/grDevices"
"C:/PROGRA~1/R/R-25~1.1/library/utils"
"C:/PROGRA~1/R/R-25~1.1/library/datasets"
"C:/PROGRA~1/R/R-25~1.1/library/methods"
"Autoloads"
"C:/PROGRA~1/R/R-25~1.1/library/base"
땒 시스템이 땓땁땓딬 땓땐땓땓 혹은 땓땰땬땵땳 와 같은 상용 딨땣땯땭땭땥땲땣땩땡땬딩 통계소프트웨어에 비하여
지니고 있는 장점 중의 하나는 자료의 분석에 필요한 모듈이 매우 다양하다는 점이다딮 이는
땒 이 공개소프트웨어이면서 사용자가 자신의 모듈을 쉽게 시스템에 접목할 수 있도록 하는
유연한 땁땐땉 및 제작도구를 제공하고 있기 때문이다딮 특정 사용자가 자체 제작한 모듈을 땒
홈페이지에 업로드하면 이는 모든 사용자에게 공개되어 이를 필요로 하는 일반 사용자가
다운로드하여 사용할 수 있다딮 특정 사용자가 자체 제작한 모듈을 패키지라고 부르며딬 땒딭
땧땵땩 는 이를 다운로드 및 설치를 도와주는 도구를 제공한다딮
땒딭땧땵땩 의 메뉴바의 땐땡땣땫땡땧땥땳 를 선택하고 풀다운 메뉴에서 땉땮땳땴땡땬땬 땰땡땣땫땡땧땥 를 선택하면
다운로드 사이트 딨땆땩땧땵땲땥 딱딲딮딴 좌측딩 및 다운로드할 수 있는 패키지들이 나열된 리스트창
딨땆땩땧땵땲땥 딱딲딮딴 우측딩 이 나온다딮 이 리스트 창에서 원하는 패키지를 다운로드할 수 있다딮 이
리스트창에는 단지 패키지 이름만 나열되어 있기 때문에 패키지의 용도는 스스로 알아봐야
한다딮 패키지의 용도를 알아내는 방법으로는 땒 홈페이지에서 좌측윈도의 땐땡땣땫땡땧땥 를 클릭
하면 땐땡땣땫땡땧땥 땬땩땳땴 와 그 용도에 대한 설명이 간략하게 나와 있으므로 참고하기 바란다딮
딸딱
그림 딱딲딮딴딺 땉땮땳땴땡땬땬 땴땨땥 땒 땣땯땮땴땲땩땢땵땴땥땤 땰땡땣땫땡땧땥
아래는 품질관리의 관리도를 그리기 위한 패키지인 qcc 를 다운로드하여 설치를 완료하
였을 때 땒딭땧땵땩 에 나타나는 메시지이다딮 네트워크의 사정으로 인해서 간혹 다운로드 혹은
설치에 실패하는 경우가 있으므로 이 메시지를 반드시 확인하기 바란다딮
> utils:::menuInstallPkgs()
Warning: unable to access index for repository http://www.stats.ox.ac.uk/pub/RWin/bin
/windows/contrib/2.5
trying URL ’http://bibs.snu.ac.kr/R/bin/windows/contrib/2.5/qcc_1.2.zip’
Content type ’application/zip’ length 318673 bytes
opened URL
downloaded 311Kb
package ’qcc’ successfully unpacked and MD5 sums checked
The downloaded packages are in
C:\Documents and Settings\star\Local Settings\Temp\RtmpzkpPsb\downloaded_packages
updating HTML package descriptions
딸딲
제 13 장
기본 유틸리티
땒 은 사용자의 편의를 위해서 통계분석 이외에 아래와 다양한 유틸리티를 제공하고 있다딮
아래는 많이 이용되는 유틸리티에 대한 설명이다딮
• ls()딺 작업공간에 있는 객체 딨땯땢땪땥땣땴땳딩 를 보여준다딮 여기서 객체는 상수딬 데이터프레
임딬 벡터딬 행렬딬 함수등 땒 에서 정의된 객체들이다딮
> ls()
[1] "BostonHousing"
[4] "pred"
[7] "spam.p"
[10] "t1.1"
"BostonHousing2" "cvt1"
"resid"
"RSS"
"spam.t"
"t1"
• rm()딺 작업공간에 있는 객체 중에서 딨딩안에 지정한 특정 객체 딨땯땢땪땥땣땴땳딩 를 삭제한다딮
> rm(BostonHousing2, cvt1, t1.1, spam.p)
> ls()
[1] "BostonHousing" "pred"
"resid"
[5] "spam.t"
"t1"
"RSS"
• help(), ?딺 딨딩안에 지정한 객체 딨함수딬 데이터딩 의 설명을 아래 땆땩땧땵땲땥 딱딳딮딱 처럼 보여
준다딮 땨땥땬땰딨딩 대신 딿 를 사용할 수 있다딮
• library()딺 딨딩안에 지정한 땰땡땣땫땡땧땥 를 로드한다딮
• scan()딺 딨딩안에 지정한 외부파일을 벡터 형태로 로드한다딮
• read.table(), read.csv()딺 딨딩안에 지정한 외부파일을 데이터프레임 형태로 로드한
다딮
딸딳
그림 딱딳딮딱딺 땗땩땮땤땯땷땳 땨땥땬땰
• write.table(), write.csv()딺 딨딩안에 지정한 객체를 외부파일로 저장한다딮
• save(), save.image()딺 딨딩안에 지정한 객체를 땒 땤땡땴땡 형식으로 저장한다딮
x <- runif(20)
y <- list(a = 1, b = TRUE, c = "oops")
save(x, y, file = "xy.Rdata")
save.image()
• load(), unlink()딺 딨딩안에 지정한 땒 땤땡땴땡 파일을 작업환경으로 로드하거나딬 메모리
에 로드했던 땒땤땡땴땡 를 땵땮땬땯땡땤 한다딮
load("all.Rdata", .GlobalEnv)
unlink("all.Rdata")
• sink()딺 땒 코드를 실행할 때 나타나는 화면의 출력 내용을 파일로 저장려고 할 때 사
용한다딮 이 경우 화면에는 출력되지 않는다딮 파일로 저장되던 내용을 다시 화면으로
출력하게 하려면 땳땩땮땫딨딩라고 하면 된다딮
zz <- file("all.Rout", open="wt")
sink(zz)
unlink(zz)
sink()
딸딴
제 14 장
객체 (R objects)
땒 땯땢땪땥땣땴땳 에는 아래와 같은 종류들이 있고딬 기본적으로 땒 은 땏땏땐딨땏땢땪땥땣땴 땏땲땩땥땮땴땥땤 땐땲땯딭
땧땲땡땭땭땩땮땧딩 개념에 의해 설계되었기 때문에 땒 에서 사용되는 대부분이 땯땢땪땥땣땴 로 간주 될 수
있다딮
• 땡땴땯땭땩땣 딨상수딩
• 땶땥땣땴땯땲
• 땭땡땴땲땩땸
• 땬땩땳땴
• 땤땡땴땡딮땦땲땡땭땥
• 땦땵땮땣땴땩땯땮
• 땯땰땥땲땡땴땯땲 딮딮딮
위의 땒 오브젝트의 분류 중에서 atomic, vector, matrix, data.frame 을 데이터 오브젝
트라고 부른다딮
제1절
Data object 의 storage mode
땒 에서 모든 데이터 오브젝트는 딴 가지 종류의 저장 타입 딨땭땯땤땥 땯땲 땳땴땯땲땡땧땥 땭땯땤땥딩 있다딮딮 아
래는 데이터 오브젝트 중 땡땴땯땭땩땣 오브젝트의 딴 가지 땭땯땤땥 에 대한 예이다딮 이러한 딴 종류의
땭땯땤땥 는 땶땥땣땴땯땲딬 땭땡땴땲땩땸딬 땡땲땲땡땹 등에 공통적으로 적용된다딮
• 숫자형 딨땮땵땭땥땲땩땣딩
딸딵
> value <- 605
> value
[1] 605
• 문자형 딨땣땨땡땲땡땣땴땥땲딩
> string <- "Hello World"
> string
[1] "Hello World"
• 논리형 딨땬땯땧땩땣땡땬딩
> 2 < 4
[1] TRUE
• 복소수형 딨땣땯땭땰땬땥땸 땮땵땭땢땥땲딩
> cn <- 2 + 3i
> cn
[1] 2+3i
땒 에서는 데이터의 땭땯땤땥 를 확인하는 함수로 mode()가 있다딮
> mode(value)
[1] "numeric"
> mode(string)
[1] "character"
> mode(2<4)
[1] "logical"
데이터 오브젝트는 class 라는 속성을 부여할 수 있는 데딬 만일 데이터 오브젝트의 땣땬땡땳땳
속성을 따로 부여하지 않을 경우 땣땬땡땳땳 속성은 데이터의 땭땯땤땥 와 동일하다딮
> string <- "Hello World"
> mode(string)
[1] "character"
> class(string)
[1] "character"
> class(string)<-"myclass" ## string의 class를 "myclass"로 부여
> class(string)
[1] "myclass"
딸딶
제2절
vector
벡터는 하나 이상의 원소 딨땡땴땯땭땩땣딩 로 이루어진 자료구조이다딮 또한 벡터를 구성하고 있는
원소 딨땡땴땯땭땩땣딩 는 그 형태 딨땭땯땤땥딩 가 동일해야 한다딮 즉딬 딨딱, 딲, 딢a딢, 딢b딢딩 와 같은 벡터는 있을
수가 없다딮 아래는 벡터를 생성하는 코드이다딮
x1<-c(1,2,3,4)
x2<-1:3
x3<-c("A", "B", "C")
벡터의 길이 딨땬땥땮땧땴땨딩 를 나타내는 함수는 length()가 있다딮
length(x1)
[1] 4
length(x3)
[1] 3
length(x3)
[1] 4
벡터를 생성하는 함수로는 아래와 같은 것들이 있다딮
• 땲땥땰딨딩딬 땳땥땱딨딩딺
# 2를 2번 반복
> rep(2, 2)
[1] 2 2
# vector (1,2)의 원소를 각각 2번 반복
> rep(c(1,2), each=2)
[1] 1 1 2 2
#0과 1을 등구간인 11개 숫자로 이루어진 벡터를 만듬
seq(0, 1, length=11)
[1] 0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
#1에서 9까지 2씩 증가하는 숫자로 이루어진 벡터를 만듬
seq(1, 9, by = 2)
[1] 1 3 5 7 9
• 땮땵땭땥땲땩땣딨딩딬 땤땯땵땢땬땥딨딩딬 땩땮땴땥땧땥땲딨딩딬 땣땨땡땲땡땣땴땥땲딨딩딺 속성이 땮땵땭땥땲땩땣딬 땤땯땵땢땬땥딬 땩땮땴땥땧땥땲딬 혹은
땣땨땡땲땡땣땴땥땲 인 벡터를 괄호안의 수만큼 할당함
> x<-integer(length = 10)
> x
[1] 0 0 0 0 0 0 0 0 0 0
딸딷
땒 데이터 오브젝트중 땮땵땭땥땲땩땣 땶땥땣땴땯땲 는 다음과 같은 땣땬땡땳땳 속성을 가질 수 있다딮 이는
자료의 속성을 연속형딬 범주형 변수로 구분하는 것과 같은 맥락으로 이해하면 된다딮
• 땮땵땭땥땲땩땣딺 연속형
• 땦땡땣땴땯땲딺 범주형
• 땯땲땤땥땲땥땤딺 순서있는 범주형
아래의 표는 모두 땮땵땭땥땲땩땣 땶땥땣땴땯땲 인데도 불구하고 땣땬땡땳땳 속성이 서로 다른 경우에 대한 예
시이다딮
표 딱딴딮딱딺 벡터오브젝트의 땭땯땤땥 및 땣땬땡땳땳
땒 땣땯땤땥
땭땯땤땥딨땸딩
땣땬땡땳땳딨땸딩
땸 < − 땣딨딱딺딱따딩
딢땮땵땭땥땲땩땣딢
딢땮땵땭땥땲땩땣딢
땸< −땦땡땣땴땯땲딨딱딺딱따딩 딢땮땵땭땥땲땩땣딢
딢땦땡땣땴땯땲딢
땸< −땯땲땤땥땲땥땤딨딱딺딱따딩 딢땮땵땭땥땲땩땣딢 딢땯땲땤땥땲땥땤딢 딢땦땡땣땴땯땲딢
땒 데이터오브젝트의 땣땯땭땰땯땮땥땮땴 를 접근하는 방법은 아래와 같이 인덱스와 땣땯땭땰땯땮땥땮땴
이름을 이용한다딮
object [ arg1, ... , argn ]
object [[ arg1, ... , argn ]]
object $ tag
제3절
matrix
제4절
data frame
# for vector, matrix, array
# for list
# for data.frame or named list
L3 <- LETTERS[1:3]
d <- data.frame(cbind(x=1, y=1:10), fac=sample(L3, 10, repl=TRUE))
data.frame(cbind( 1,
1:10),
sample(L3, 10, repl=TRUE))
is.data.frame(d)
제5절
+
*
R operators
:Minus, can be unary or binary
:Plus, can be unary or binary
:Multiplication, binary
딸딸
/
%%
<
>
==
>=
<=
!
:
^
&
|
<<<->
=
$
:Division, binary
:Modulus, binary
:Less than, binary
:Greater than, binary
:Equal to, binary
:Greater than or equal to, binary
:Less than or equal to, binary
:Unary not
:Sequence, binary (in model formulae: interaction)
:Exponentiation, binary
:And, binary, vectorized && :And, binary, not vectorized
:Or, binary, vectorized || :Or, binary, not vectorized
:Left assignment, binary,
: global assignment
:Right assignment, binary
:Left ssignment, binary
:List subset, binary
딸딹
딹따
제 15 장
R programming
제1절
조건문
조건문에 해당되는 표현으로는 다음의 딳 가지 종류가 있다딮
if ( cond ) expr
if ( cond ) expr1 else expr2
if ( cond1 ) expr1
else if( cond2 ) expr2
else expr3
제2절
순환문
순환문의 표현으로는 다음 세가지 표현을 사용한다딮
while ( cond ) expr
repeat expr
for ( var in list ) expr
위에서 땷땨땩땬땥딬 땲땥땰땥땡땴딬 땦땯땲 구문 안에서 순환문을 끝내기 위한 구문으로 땢땲땥땡땫 와 이후
의 문장을 건너뛰고 다음 순환을 하라는 구문인 땮땥땸땴 를 사용할 수 있다딮 이는 땃 언어에서
땢땲땥땡땫딬 그리고 땣땯땮땴땩땮땵땥 와 동일한 용도로 사용된다딮 아래의 땒 프로그램은 정규분포에서 난
수 딱따따 개를 발생시키고 이중 양수인 값들만을 합하는 프로그램이다딮
x<-rnorm(100) ## 표준정규분포에서 100개의 난수발생
sum.positive <- 0
딹딱
for(i in 1:100)
{
if(x[i] < 0) next;
sum.positive <- sum.positive + x[i]
}
제3절
R Functions: two simple examples
> name <- function(arg_1, arg_2, ...) expression
딨예제딩땭땩땬땥 을 땫땭 로 바꾸는 프로그램딮
miles.to.km <- function(miles) miles*8/5
> miles.to.km(175) # Approximate distance to Sydney, in miles
[1] 280
만일 100, 200 300 miles를 kilometer로 바꾼다면
> miles.to.km(c(100,200,300))
[1] 160 320 480
제4절
Common Useful Functions
print()
cat()
length()
mean()
median()
range()
sum()
unique()
diff()
sort()
order()
rev()
cumsum()
cumprod()
# Prints a single R object
# Prints multiple objects, one after the other
# Number of elements in a vector or of a list
#Gives the vector of distinct values
# Replace a vector by the vector of first differences
# diff(x) has one less element than x
# Sort elements into order, but omitting NAs
# x[order(x)] orders elements of x, with NAs last
# reverse the order of vector elements
딹딲
제 16 장
R 에서 C code 부르기
땗땥 땷땩땬땬 땥땸땰땬땯땲땥 땵땳땩땮땧 딮땃 땡땮땤 딮땃땡땬땬 땷땩땴땨 딷 땣땯땤땥 땥땸땡땭땰땬땥땳딺 땕땳땩땮땧 딮땃
/* useC1.c
/* Calling C with an integer vector using .C
*/
*/
void useC(int *i) {
i[0] = 11;
}
땔땨땥 땃 땦땵땮땣땴땩땯땮 땳땨땯땵땬땤 땢땥 땯땦 땴땹땰땥 땶땯땩땤딮 땔땨땥 땣땯땭땰땩땬땥땤 땣땯땤땥 땳땨땯땵땬땤 땮땯땴 땲땥땴땵땲땮 땡땮땹땴땨땩땮땧
땥땸땣땥땰땴 땴땨땲땯땵땧땨 땩땴땳 땡땲땧땵땭땥땮땴땳딮
땔땯 땣땯땭땰땩땬땥 땴땨땥 땣 땣땯땤땥딬 땴땹땰땥 땡땴 땴땨땥 땣땯땭땭땡땮땤 땰땲땯땭땰땴딺
R CMD SHLIB useC1.c
땔땨땥 땣땯땭땰땩땬땥땤 땣땯땤땥 딌땬땥 땮땡땭땥 땩땳 땵땳땥땃딱딮땳땯
땉땮 땒딺
> dyn.load("useC1.so")
> a <- 1:10
# integer vector
> a
[1] 1 2 3 4 5 6 7 8 9 10
> out <- .C("useC", b = as.integer(a))
> a
[1] 1 2 3 4 5 6 7 8 9 10
> out$b
[1] 11 2 3 4 5 6 7 8 9 10
딹딳
• 땙땯땵 땨땡땶땥 땴땯 땡땬땬땯땣땡땴땥 땭땥땭땯땲땹 땴땯 땴땨땥 땶땥땣땴땯땲땳 땰땡땳땳땥땤 땴땯 딮땃 땩땮 땒 땢땹 땣땲땥땡땴땩땮땧 땶땥땣땴땯땲땳
땯땦 땴땨땥 땲땩땧땨땴 땬땥땮땧땴땨딮
• 땔땨땥 딌땲땳땴 땡땲땧땵땭땥땮땴 땴땯 딮땃 땩땳 땡 땣땨땡땲땡땣땴땥땲 땳땴땲땩땮땧 땯땦 땴땨땥 땃 땦땵땮땣땴땩땯땮 땮땡땭땥딮
• 땔땨땥 땲땥땳땴 땯땦 땴땨땥 땡땲땧땵땭땥땮땴땳 땡땲땥 땒 땯땢땪땥땣땴땳 땴땯 땢땥 땰땡땳땳땥땤 땴땯 땴땨땥 땃 땦땵땮땣땴땩땯땮딮
• 땁땬땬 땡땲땧땵땭땥땮땴땳 땳땨땯땵땬땤 땢땥 땣땯땥땲땣땥땤 땴땯 땴땨땥 땣땯땲땲땥땣땴 땒 땳땴땯땲땡땧땥 땭땯땤땥 땴땯 땰땲땥땶땥땮땴 땭땩땳딭
땭땡땴땣땨땩땮땧 땯땦 땴땹땰땥땳 땴땨땡땴 땣땡땮 땬땥땡땤 땴땯 땥땲땲땯땲땳딮
• 딮땃 땲땥땴땵땲땮땳 땡 땬땩땳땴 땯땢땪땥땣땴딮
• 땔땨땥 땳땥땣땯땮땤 딮땃 땡땲땧땵땭땥땮땴 땩땳 땧땩땶땥땮 땴땨땥 땮땡땭땥 땢딮 땔땨땩땳 땮땡땭땥 땩땳 땵땳땥땤 땦땯땲 땴땨땥 땲땥땳땰땥땣땴땩땶땥
땣땯땭땰땯땮땥땮땴 땩땮 땴땨땥 땲땥땴땵땲땮땥땤 땬땩땳땴 땯땢땪땥땣땴 딨땢땵땴 땮땯땴 땰땡땳땳땥땤 땴땯 땴땨땥 땣땯땭땰땩땬땥땤 땣땯땤땥딩딮
땉땉딮
/* useC2.c
/* Calling C with different vector types using .C
*/
*/
void useC(int *i, double *d, char **c, int *l) {
i[0] = 11;
d[0] = 2.333;
c[1] = "g";
l[0] = 0;
}
땔땯 땣땯땭땰땩땬땥 땴땨땥 땣 땣땯땤땥딬 땴땹땰땥 땡땴 땴땨땥 땣땯땭땭땡땮땤 땰땲땯땭땰땴딺
R CMD SHLIB useC2.c
땴땯 땧땥땴 땵땳땥땃딲딮땳땯
땔땯 땣땯땭땰땩땬땥 땭땯땲땥 땴땨땡땮 땯땮땥 땣 딌땬땥딺
R CMD SHLIB file1.c file2.c file3.c
땴땯 땧땥땴 딌땬땥딱딮땳땯
땉땮 땒딺
>
>
>
>
dyn.load("useC2.so")
i <- 1:10
d <- seq(length=3, from=1, to=2)
c <- c("a", "b", "c")
딹딴
# integer vector
# real number vector
# string vector
> l <- c("TRUE", "FALSE")
> i
[1] 1 2 3 4 5 6 7 8 9 10
> d
[1] 1.0 1.5 2.0
> c
[1] "a" "b" "c"
> l
[1] "TRUE" "FALSE"
>
> out <- .C("useC",
i1 = as.integer(a),
d1 = as.numeric(d),
c1 = as.character(c),
l1 = as.logical(l))
> out
$i1
[1] 11 2 3 4 5 6 7 8 9 10
$d1
[1] 2.333 1.500 2.000
$c1
[1] "a" "g" "c"
$l1
[1] FALSE FALSE
딹딵
# logical vector
딹딶
제 17 장
R Graphics
데이터분석을 하는데 그래프는 없어서는 안될 중요한 요소이다딮 땒 은 어떤 통계소프트웨어
보다도 다양한 그래픽 기능을 제공해 주고 있으며딬 이를 잘 활용한다면 통계분석의 질을
한층 드높일 수 있을 것이다딮 더우기 땒 의 그래픽함수들을 조합함으로써 원하는 형태의 새
로운 그래픽을 생성할 수도 있다딮
땔땨땥 땧땲땡땰땨땩땣땳 땦땡땣땩땬땩땴땩땥땳 땣땡땮 땢땥 땵땳땥땤 땩땮 땢땯땴땨 땩땮땴땥땲땡땣땴땩땶땥 땡땮땤 땢땡땴땣땨 땭땯땤땥땳딬 땢땵땴 땩땮 땭땯땳땴
땣땡땳땥땳딬 땩땮땴땥땲땡땣땴땩땶땥 땵땳땥 땩땳 땭땯땲땥 땰땲땯땤땵땣땴땩땶땥딮 땉땮땴땥땲땡땣땴땩땶땥 땵땳땥 땩땳 땡땬땳땯 땥땡땳땹 땢땥땣땡땵땳땥 땡땴 땳땴땡땲땴땵땰
땴땩땭땥 땒 땩땮땩땴땩땡땴땥땳 땡 땧땲땡땰땨땩땣땳 땤땥땶땩땣땥 땤땲땩땶땥땲 땷땨땩땣땨 땯땰땥땮땳 땡 땳땰땥땣땩땡땬 땧땲땡땰땨땩땣땳 땷땩땮땤땯땷 땦땯땲 땴땨땥
땤땩땳땰땬땡땹 땯땦 땩땮땴땥땲땡땣땴땩땶땥 땧땲땡땰땨땩땣땳딮 땁땬땴땨땯땵땧땨 땴땨땩땳 땩땳 땤땯땮땥 땡땵땴땯땭땡땴땩땣땡땬땬땹딬 땩땴 땩땳 땵땳땥땦땵땬 땴땯 땫땮땯땷
땴땨땡땴 땴땨땥 땣땯땭땭땡땮땤 땵땳땥땤 땩땳 땘딱딱딨딩 땵땮땤땥땲 땕땎땉땘 땡땮땤 땷땩땮땤땯땷땳딨딩 땵땮땤땥땲 땗땩땮땤땯땷땳딮
땏땮땣땥 땴땨땥 땤땥땶땩땣땥 땤땲땩땶땥땲 땩땳 땲땵땮땮땩땮땧딬 땒 땰땬땯땴땴땩땮땧 땣땯땭땭땡땮땤땳 땣땡땮 땢땥 땵땳땥땤 땴땯 땰땲땯땤땵땣땥 땡
땶땡땲땩땥땴땹 땯땦 땧땲땡땰땨땩땣땡땬 땤땩땳땰땬땡땹땳 땡땮땤 땴땯 땣땲땥땡땴땥 땥땮땴땩땲땥땬땹 땮땥땷 땫땩땮땤땳 땯땦 땤땩땳땰땬땡땹딮
땐땬땯땴땴땩땮땧 땣땯땭땭땡땮땤땳 땡땲땥 땤땩땶땩땤땥땤 땩땮땴땯 땴땨땲땥땥 땢땡땳땩땣 땧땲땯땵땰땳딺
• High-level plotting functions 땣땲땥땡땴땥 땡 땮땥땷 땰땬땯땴 땯땮 땴땨땥 땧땲땡땰땨땩땣땳 땤땥땶땩땣땥딬 땰땯땳땳땩땢땬땹
땷땩땴땨 땡땸땥땳딬 땬땡땢땥땬땳딬 땴땩땴땬땥땳 땡땮땤 땳땯 땯땮딮
• Low-level plotting functions 땡땤땤 땭땯땲땥 땩땮땦땯땲땭땡땴땩땯땮 땴땯 땡땮 땥땸땩땳땴땩땮땧 땰땬땯땴딬 땳땵땣땨 땡땳
땥땸땴땲땡 땰땯땩땮땴땳딬 땬땩땮땥땳 땡땮땤 땬땡땢땥땬땳딮
• Interactive graphics functions 땡땬땬땯땷 땹땯땵 땩땮땴땥땲땡땣땴땩땶땥땬땹 땡땤땤 땩땮땦땯땲땭땡땴땩땯땮 땴땯딬 땯땲
땥땸땴땲땡땣땴 땩땮땦땯땲땭땡땴땩땯땮 땦땲땯땭딬 땡땮 땥땸땩땳땴땩땮땧 땰땬땯땴딬 땵땳땩땮땧 땡 땰땯땩땮땴땩땮땧 땤땥땶땩땣땥 땳땵땣땨 땡땳 땡 땭땯땵땳땥딮
땉땮 땡땤땤땩땴땩땯땮딬 땒 땭땡땩땮땴땡땩땮땳 땡 땬땩땳땴 땯땦 땧땲땡땰땨땩땣땡땬 땰땡땲땡땭땥땴땥땲땳 땷땨땩땣땨 땣땡땮 땢땥 땭땡땮땩땰땵땬땡땴땥땤
땴땯 땣땵땳땴땯땭땩땺땥 땹땯땵땲 땰땬땯땴땳딮
딹딷
그림 딱딷딮딱딺 땈땩땧땨딭땬땥땶땥땬 땰땬땯땴땳
딹딸
제1절
High-level plotting commands
땈땩땧땨딭땬땥땶땥땬 땰땬땯땴땴땩땮땧 땦땵땮땣땴땩땯땮땳 땡땲땥 땤땥땳땩땧땮땥땤 땴땯 땧땥땮땥땲땡땴땥 땡 땣땯땭땰땬땥땴땥 땰땬땯땴 땯땦 땴땨땥 땤땡땴땡 땰땡땳땳땥땤
땡땳 땡땲땧땵땭땥땮땴땳 땴땯 땴땨땥 땦땵땮땣땴땩땯땮딮 땗땨땥땲땥 땡땰땰땲땯땰땲땩땡땴땥딬 땡땸땥땳딬 땬땡땢땥땬땳 땡땮땤 땴땩땴땬땥땳 땡땲땥 땡땵땴땯땭땡땴딭
땩땣땡땬땬땹 땧땥땮땥땲땡땴땥땤 딨땵땮땬땥땳땳 땹땯땵 땲땥땱땵땥땳땴 땯땴땨땥땲땷땩땳땥딮딩 땈땩땧땨딭땬땥땶땥땬 땰땬땯땴땴땩땮땧 땣땯땭땭땡땮땤땳 땡땬땷땡땹땳
땳땴땡땲땴 땡 땮땥땷 땰땬땯땴딬 땥땲땡땳땩땮땧 땴땨땥 땣땵땲땲땥땮땴 땰땬땯땴 땩땦 땮땥땣땥땳땳땡땲땹딮
1.0.1
The plot() function
땏땮땥 땯땦 땴땨땥 땭땯땳땴 땦땲땥땱땵땥땮땴땬땹 땵땳땥땤 땰땬땯땴땴땩땮땧 땦땵땮땣땴땩땯땮땳 땩땮 땒 땩땳 땴땨땥 땰땬땯땴딨딩 땦땵땮땣땴땩땯땮딮 땔땨땩땳 땩땳
땡 땧땥땮땥땲땩땣 땦땵땮땣땴땩땯땮딺 땴땨땥 땴땹땰땥 땯땦 땰땬땯땴 땰땲땯땤땵땣땥땤 땩땳 땤땥땰땥땮땤땥땮땴 땯땮 땴땨땥 땴땹땰땥 땯땲 땣땬땡땳땳 땯땦 땴땨땥
딌땲땳땴 땡땲땧땵땭땥땮땴딮
plot(x, y) # scatterplot of y against x
plot(y~x) #
plot(x)
땉땦 땸 땩땳 땡 땴땩땭땥 땳땥땲땩땥땳딬 땴땨땩땳 땰땲땯땤땵땣땥땳 땡 땴땩땭땥딭땳땥땲땩땥땳 땰땬땯땴딮 땉땦 땸 땩땳 땡 땮땵땭땥땲땩땣 땶땥땣땴땯땲딬 땩땴
땰땲땯땤땵땣땥땳 땡 땰땬땯땴 땯땦 땴땨땥 땶땡땬땵땥땳 땩땮 땴땨땥 땶땥땣땴땯땲 땡땧땡땩땮땳땴 땴땨땥땩땲 땩땮땤땥땸 땩땮 땴땨땥 땶땥땣땴땯땲딮 땉땦 땸 땩땳 땡
땣땯땭땰땬땥땸 땶땥땣땴땯땲딬 땩땴 땰땲땯땤땵땣땥땳 땡 땰땬땯땴 땯땦 땩땭땡땧땩땮땡땲땹 땶땥땲땳땵땳 땲땥땡땬 땰땡땲땴땳 땯땦 땴땨땥 땶땥땣땴땯땲 땥땬땥땭땥땮땴땳딮
plot(f)
plot(f, y)
# bar plot of f
# boxplots of y for each level of f
땷땨땥땲땥 f 땩땳 땡 땦땡땣땴땯땲 땯땢땪땥땣땴딬 y 땩땳 땡 땮땵땭땥땲땩땣 땶땥땣땴땯땲딮
plot(df)
plot(~ expr)
plot(y ~ expr)
# df is a data frame,
# y is any object, expr is a list of object names
# separated by ‘+’ (e.g., a + b + c).
땔땨땥 딌땲땳땴 땴땷땯 땦땯땲땭땳 땰땲땯땤땵땣땥 땤땩땳땴땲땩땢땵땴땩땯땮땡땬 땰땬땯땴땳 땯땦 땴땨땥 땶땡땲땩땡땢땬땥땳 땩땮 땡 땤땡땴땡 땦땲땡땭땥 딨딌땲땳땴
땦땯땲땭딩 땯땲 땯땦 땡 땮땵땭땢땥땲 땯땦 땮땡땭땥땤 땯땢땪땥땣땴땳 딨땳땥땣땯땮땤 땦땯땲땭딩딮 땔땨땥 땴땨땩땲땤 땦땯땲땭 땰땬땯땴땳 땹 땡땧땡땩땮땳땴
땥땶땥땲땹 땯땢땪땥땣땴 땮땡땭땥땤 땩땮 땥땸땰땲딮
1.0.2
Displaying multivariate data
땒 땰땲땯땶땩땤땥땳 땴땷땯 땶땥땲땹 땵땳땥땦땵땬 땦땵땮땣땴땩땯땮땳 땦땯땲 땲땥땰땲땥땳땥땮땴땩땮땧 땭땵땬땴땩땶땡땲땩땡땴땥 땤땡땴땡딮 땉땦 땘 땩땳 땡 땮땵땭땥땲땩땣
땭땡땴땲땩땸 땯땲 땤땡땴땡 땦땲땡땭땥딬 땴땨땥 땣땯땭땭땡땮땤
딹딹
• 땰땡땩땲땳딨땘딩
땰땲땯땤땵땣땥땳 땡 땰땡땩땲땷땩땳땥 땳땣땡땴땴땥땲땰땬땯땴 땭땡땴땲땩땸 땯땦 땴땨땥 땶땡땲땩땡땢땬땥땳 땤땥딌땮땥땤 땢땹 땴땨땥 땣땯땬땵땭땮땳 땯땦
땘딬 땴땨땡땴 땩땳딬 땥땶땥땲땹 땣땯땬땵땭땮 땯땦 땘 땩땳 땰땬땯땴땴땥땤 땡땧땡땩땮땳땴 땥땶땥땲땹 땯땴땨땥땲 땣땯땬땵땭땮 땯땦 땘 땡땮땤 땴땨땥
땲땥땳땵땬땴땩땮땧 n딨n − 딱딩 땰땬땯땴땳 땡땲땥 땡땲땲땡땮땧땥땤 땩땮 땡 땭땡땴땲땩땸 땷땩땴땨 땰땬땯땴 땳땣땡땬땥땳 땣땯땮땳땴땡땮땴 땯땶땥땲 땴땨땥
땲땯땷땳 땡땮땤 땣땯땬땵땭땮땳 땯땦 땴땨땥 땭땡땴땲땩땸딮
# pairs function
pairs(state.x77[,1:5],main = "Information from 50 States of America",pch = 16)
pairs(state.x77[,1:5],main = "Information from 50 States of America",pch = 16,
panel=panel.smooth)
그림 딱딷딮딲딺 땰땡땩땲땳딨딩 땰땬땯땴땳
• 땣땯땰땬땯땴딨땡 ∼ 땢 땼 땣딩딬 땣땯땰땬땯땴딨땡 ∼ 땢 땼 땣 딫 땤딩
땰땲땯땤땵땣땥땳 땡 땮땵땭땢땥땲 땯땦 땳땣땡땴땴땥땲땰땬땯땴땳 땯땦 땡 땡땧땡땩땮땳땴 땢 땦땯땲 땧땩땶땥땮 땶땡땬땵땥땳 땯땦 땣딮 땉땦 땣 땩땳 땡
땦땡땣땴땯땲딬 땴땨땩땳 땳땩땭땰땬땹 땭땥땡땮땳 땴땨땡땴 땡 땩땳 땰땬땯땴땴땥땤 땡땧땡땩땮땳땴 땢 땦땯땲 땥땶땥땲땹 땬땥땶땥땬 땯땦 땣딮 땗땨땥땮
땣 땩땳 땮땵땭땥땲땩땣딬 땩땴 땩땳 땤땩땶땩땤땥땤 땩땮땴땯 땡 땮땵땭땢땥땲 땯땦 땣땯땮땤땩땴땩땯땮땩땮땧 땩땮땴땥땲땶땡땬땳 땡땮땤 땦땯땲 땥땡땣땨
땩땮땴땥땲땶땡땬 땡 땩땳 땰땬땯땴땴땥땤 땡땧땡땩땮땳땴 땢 땦땯땲 땶땡땬땵땥땳 땯땦 땣 땷땩땴땨땩땮 땴땨땥 땩땮땴땥땲땶땡땬딮 땔땨땥 땮땵땭땢땥땲 땡땮땤
땰땯땳땩땴땩땯땮 땯땦 땩땮땴땥땲땶땡땬땳 땣땡땮 땢땥 땣땯땮땴땲땯땬땬땥땤 땷땩땴땨 땧땩땶땥땮딮땶땡땬땵땥땳딽 땡땲땧땵땭땥땮땴 땴땯 땣땯땰땬땯땴딨딩딿땴땨땥
땦땵땮땣땴땩땯땮 땣땯딮땩땮땴땥땲땶땡땬땳딨딩 땩땳 땵땳땥땦땵땬 땦땯땲 땳땥땬땥땣땴땩땮땧 땩땮땴땥땲땶땡땬땳딮
딱따따
그림 딱딷딮딳딺 땣땯땰땬땯땴딨딩 땰땬땯땴땳
coplot(Sepal.Length~Sepal.Width|Species, iris)
땔땨땥 땣땯땰땬땯땴딨딩 땡땮땤 땰땡땩땲땳딨딩 땦땵땮땣땴땩땯땮 땢땯땴땨 땴땡땫땥 땡땮 땡땲땧땵땭땥땮땴 땰땡땮땥땬딽 땷땨땩땣땨 땣땡땮 땢땥 땵땳땥땤
땴땯 땣땵땳땴땯땭땩땺땥 땴땨땥 땴땹땰땥 땯땦 땰땬땯땴 땷땨땩땣땨 땡땰땰땥땡땲땳 땩땮 땥땡땣땨 땰땡땮땥땬딮 땔땨땥 땤땥땦땡땵땬땴 땩땳 땰땯땩땮땴땳딨딩
땴땯 땰땲땯땤땵땣땥 땡 땳땣땡땴땴땥땲땰땬땯땴 땢땵땴 땢땹 땳땵땰땰땬땹땩땮땧 땳땯땭땥 땯땴땨땥땲 땬땯땷딭땬땥땶땥땬 땧땲땡땰땨땩땣땳 땦땵땮땣땴땩땯땮
땯땦 땴땷땯 땶땥땣땴땯땲땳 땸 땡땮땤 땹 땡땳 땴땨땥 땶땡땬땵땥 땯땦 땰땡땮땥땬딽 땹땯땵 땣땡땮 땰땲땯땤땵땣땥 땡땮땹 땴땹땰땥 땯땦 땰땬땯땴
땹땯땵 땷땩땳땨딮 땁땮 땥땸땡땭땰땬땥 땰땡땮땥땬 땦땵땮땣땴땩땯땮 땵땳땥땦땵땬 땦땯땲 땣땯땰땬땯땴땳 땩땳 땰땡땮땥땬딮땳땭땯땯땴땨딨딩딮
1.0.3
Display graphics
땏땴땨땥땲 땨땩땧땨딭땬땥땶땥땬 땧땲땡땰땨땩땣땳 땦땵땮땣땴땩땯땮땳 땰땲땯땤땵땣땥 땤땩딋땥땲땥땮땴 땴땹땰땥땳 땯땦 땰땬땯땴땳딮 땓땯땭땥 땥땸땡땭땰땬땥땳 땡땲땥딺
• 땱땱땮땯땲땭딨땸딩딬 땱땱땬땩땮땥딨땸딩딬 땱땱땰땬땯땴딨땸딬 땹딩
땄땩땳땴땲땩땢땵땴땩땯땮딭땣땯땭땰땡땲땩땳땯땮 땰땬땯땴땳딮 땔땨땥 딌땲땳땴 땦땯땲땭 땰땬땯땴땳 땴땨땥 땮땵땭땥땲땩땣 땶땥땣땴땯땲 땸 땡땧땡땩땮땳땴
땴땨땥 땥땸땰땥땣땴땥땤 땎땯땲땭땡땬 땯땲땤땥땲 땳땣땯땲땥땳 딨땡 땮땯땲땭땡땬 땳땣땯땲땥땳 땰땬땯땴딩 땡땮땤 땴땨땥 땳땥땣땯땮땤 땡땤땤땳 땡
땳땴땲땡땩땧땨땴 땬땩땮땥 땴땯 땳땵땣땨 땡 땰땬땯땴 땢땹 땤땲땡땷땩땮땧 땡 땬땩땮땥 땴땨땲땯땵땧땨 땴땨땥 땤땩땳땴땲땩땢땵땴땩땯땮 땡땮땤 땤땡땴땡
땱땵땡땲땴땩땬땥땳딮 땔땨땥 땴땨땩땲땤 땦땯땲땭 땰땬땯땴땳 땴땨땥 땱땵땡땮땴땩땬땥땳 땯땦 땸 땡땧땡땩땮땳땴 땴땨땯땳땥 땯땦 땹 땴땯 땣땯땭땰땡땲땥
땴땨땥땩땲 땲땥땳땰땥땣땴땩땶땥 땤땩땳땴땲땩땢땵땴땩땯땮땳딮
# Distribution of MPG for Cars93 Dataset
딱따딱
attach(Cars93)
# Q-Q Plot
qqnorm(MPG.highway,main="Normal Q-Qplot")
qqline(MPG.highway)
• 땨땩땳땴딨땸딩딬 땨땩땳땴딨땸딬 땮땣땬땡땳땳딽땮딩딬 땨땩땳땴딨땸딬 땢땲땥땡땫땳딽땢딬 딮딮딮딩
땐땲땯땤땵땣땥땳 땡 땨땩땳땴땯땧땲땡땭 땯땦 땴땨땥 땮땵땭땥땲땩땣 땶땥땣땴땯땲 땸딮 땁 땳땥땮땳땩땢땬땥 땮땵땭땢땥땲 땯땦 땣땬땡땳땳땥땳 땩땳 땵땳땵딭
땡땬땬땹 땣땨땯땳땥땮딬 땢땵땴 땡 땲땥땣땯땭땭땥땮땤땡땴땩땯땮 땣땡땮 땢땥 땧땩땶땥땮 땷땩땴땨 땴땨땥 땮땣땬땡땳땳딽 땡땲땧땵땭땥땮땴딮 땁땬딭
땴땥땲땮땡땴땩땶땥땬땹딬 땴땨땥 땢땲땥땡땫땰땯땩땮땴땳 땣땡땮 땢땥 땳땰땥땣땩딌땥땤 땥땸땡땣땴땬땹 땷땩땴땨 땴땨땥 땢땲땥땡땫땳딽 땡땲땧땵땭땥땮땴딮
땉땦 땴땨땥 땰땲땯땢땡땢땩땬땩땴땹딽땔땒땕땅 땡땲땧땵땭땥땮땴 땩땳 땧땩땶땥땮딬 땴땨땥 땢땡땲땳 땲땥땰땲땥땳땥땮땴 땲땥땬땡땴땩땶땥 땦땲땥땱땵땥땮땣땩땥땳
땩땮땳땴땥땡땤 땯땦 땣땯땵땮땴땳딮
# Histogram
hist(MPG.highway,xlab="Miles per US Gallon",main="Histogram")
# Boxplot
boxplot(MPG.highway,main="Boxplot")
# Density
plot(density(MPG.highway),type="l",xlab="Miles per US Gallon",main="Density")
• 땤땯땴땣땨땡땲땴딨땸딬 딮딮딮딩
땃땯땮땳땴땲땵땣땴땳 땡 땤땯땴땣땨땡땲땴 땯땦 땴땨땥 땤땡땴땡 땩땮 땸딮 땉땮 땡 땤땯땴땣땨땡땲땴 땴땨땥 땹딭땡땸땩땳 땧땩땶땥땳 땡 땬땡땢땥땬땬땩땮땧
땯땦 땴땨땥 땤땡땴땡 땩땮 땸 땡땮땤 땴땨땥 땸딭땡땸땩땳 땧땩땶땥땳 땩땴땳 땶땡땬땵땥딮 땆땯땲 땥땸땡땭땰땬땥 땩땴 땡땬땬땯땷땳 땥땡땳땹 땶땩땳땵땡땬
땳땥땬땥땣땴땩땯땮 땯땦 땡땬땬 땤땡땴땡 땥땮땴땲땩땥땳 땷땩땴땨 땶땡땬땵땥땳 땬땹땩땮땧 땩땮 땳땰땥땣땩딌땥땤 땲땡땮땧땥땳딮
• 땩땭땡땧땥딨땸딬 땹딬 땺딬 딮딮딮딩딬 땣땯땮땴땯땵땲딨땸딬 땹딬 땺딬 딮딮딮딩딬 땰땥땲땳땰딨땸딬 땹딬 땺딬 딮딮딮딩
땐땬땯땴땳 땯땦 땴땨땲땥땥 땶땡땲땩땡땢땬땥땳딮 땔땨땥 땩땭땡땧땥 땰땬땯땴 땤땲땡땷땳 땡 땧땲땩땤 땯땦 땲땥땣땴땡땮땧땬땥땳 땵땳땩땮땧 땤땩딋땥땲땥땮땴
땣땯땬땯땵땲땳 땴땯 땲땥땰땲땥땳땥땮땴 땴땨땥 땶땡땬땵땥 땯땦 땺딬 땴땨땥 땣땯땮땴땯땵땲 땰땬땯땴 땤땲땡땷땳 땣땯땮땴땯땵땲 땬땩땮땥땳 땴땯 땲땥땰땲땥땳땥땮땴
땴땨땥 땶땡땬땵땥 땯땦 땺딬 땡땮땤 땴땨땥 땰땥땲땳땰 땰땬땯땴 땤땲땡땷땳 땡 딳땄 땳땵땲땦땡땣땥딮
1.0.4
Arguments to high-level plotting functions
땔땨땥땲땥 땡땲땥 땡 땮땵땭땢땥땲 땯땦 땡땲땧땵땭땥땮땴땳 땷땨땩땣땨 땭땡땹 땢땥 땰땡땳땳땥땤 땴땯 땨땩땧땨딭땬땥땶땥땬 땧땲땡땰땨땩땣땳 땦땵땮땣땴땩땯땮땳딬
땡땳 땦땯땬땬땯땷땳딺
• 땡땤땤딽땔땒땕땅
땆땯땲땣땥땳 땴땨땥 땦땵땮땣땴땩땯땮 땴땯 땡땣땴 땡땳 땡 땬땯땷딭땬땥땶땥땬 땧땲땡땰땨땩땣땳 땦땵땮땣땴땩땯땮딬 땳땵땰땥땲땩땭땰땯땳땩땮땧 땴땨땥 땰땬땯땴
땯땮 땴땨땥 땣땵땲땲땥땮땴 땰땬땯땴 딨땳땯땭땥 땦땵땮땣땴땩땯땮땳 땯땮땬땹딩딮
딱따딲
z <- 2 * volcano
# Exaggerate the relief
x <- 10 * (1:nrow(z))
# 10 meter spacing (S to N)
y <- 10 * (1:ncol(z))
# 10 meter spacing (E to W)
# image
image(x,y,z,main="Mt Eden")
# contour
contour(x,y,z,add=T)
그림 딱딷딮딴딺 땣땯땰땬땯땴딨딩 땰땬땯땴땳
• 땡땸땥땳딽땆땁때땓땅
땓땵땰땰땲땥땳땳땥땳 땧땥땮땥땲땡땴땩땯땮 땯땦 땡땸땥땳딿땵땳땥땦땵땬 땦땯땲 땡땤땤땩땮땧 땹땯땵땲 땯땷땮 땣땵땳땴땯땭 땡땸땥땳 땷땩땴땨 땴땨땥
땡땸땩땳딨딩 땦땵땮땣땴땩땯땮딮 땔땨땥 땤땥땦땡땵땬땴딬 땡땸땥땳딽땔땒땕땅딬 땭땥땡땮땳 땩땮땣땬땵땤땥 땡땸땥땳딮
• 땬땯땧딽딢땸딢딬 땬땯땧딽딢땹딢딬 땬땯땧딽딢땸땹딢
땃땡땵땳땥땳 땴땨땥 땸딬 땹 땯땲 땢땯땴땨 땡땸땥땳 땴땯 땢땥 땬땯땧땡땲땩땴땨땭땩땣딮 땔땨땩땳 땷땩땬땬 땷땯땲땫 땦땯땲 땭땡땮땹딬 땢땵땴 땮땯땴
땡땬땬딬 땴땹땰땥땳 땯땦 땰땬땯땴딮
• 땴땹땰땥 딺 땣땯땮땴땲땯땬땳 땴땨땥 땴땹땰땥 땯땦 땰땬땯땴 땰땲땯땤땵땣땥땤딬 땡땳 땦땯땬땬땯땷땳딺
– type="p" 땐땬땯땴 땩땮땤땩땶땩땤땵땡땬 땰땯땩땮땴땳 딨땴땨땥 땤땥땦땡땵땬땴딩
– type="l" 땐땬땯땴 땬땩땮땥땳
딱따딳
– type="b" 땐땬땯땴 땰땯땩땮땴땳 땣땯땮땮땥땣땴땥땤 땢땹 땬땩땮땥땳 딨땢땯땴땨딩
– type="o" 땐땬땯땴 땰땯땩땮땴땳 땯땶땥땲땬땡땩땤 땢땹 땬땩땮땥땳
– type="h" 땐땬땯땴 땶땥땲땴땩땣땡땬 땬땩땮땥땳 땦땲땯땭 땰땯땩땮땴땳 땴땯 땴땨땥 땺땥땲땯 땡땸땩땳 딨땨땩땧땨딭땤땥땮땳땩땴땹딩
– type="s" or type="S" 땓땴땥땰딭땦땵땮땣땴땩땯땮 땰땬땯땴땳딮 땉땮 땴땨땥 딌땲땳땴 땦땯땲땭딬 땴땨땥 땴땯땰 땯땦 땴땨땥
땶땥땲땴땩땣땡땬 땤땥딌땮땥땳 땴땨땥 땰땯땩땮땴딻 땩땮 땴땨땥 땳땥땣땯땮땤딬 땴땨땥 땢땯땴땴땯땭딮
– type="n" 땎땯 땰땬땯땴땴땩땮땧 땡땴 땡땬땬딮 땈땯땷땥땶땥땲 땡땸땥땳 땡땲땥 땳땴땩땬땬 땤땲땡땷땮 딨땢땹 땤땥땦땡땵땬땴딩 땡땮땤
땴땨땥 땣땯땯땲땤땩땮땡땴땥 땳땹땳땴땥땭 땩땳 땳땥땴 땵땰 땡땣땣땯땲땤땩땮땧 땴땯 땴땨땥 땤땡땴땡딮 땉땤땥땡땬 땦땯땲 땣땲땥땡땴땩땮땧 땰땬땯땴땳
땷땩땴땨 땳땵땢땳땥땱땵땥땮땴 땬땯땷딭땬땥땶땥땬 땧땲땡땰땨땩땣땳 땦땵땮땣땴땩땯땮땳딮
• 땸땬땡땢딽땳땴땲땩땮땧딬 땹땬땡땢딽땳땴땲땩땮땧
땁땸땩땳 땬땡땢땥땬땳 땦땯땲 땴땨땥 땸 땡땮땤 땹 땡땸땥땳딮 땕땳땥 땴땨땥땳땥 땡땲땧땵땭땥땮땴땳 땴땯 땣땨땡땮땧땥 땴땨땥 땤땥땦땡땵땬땴 땬땡땢땥땬땳딬
땵땳땵땡땬땬땹 땴땨땥 땮땡땭땥땳 땯땦 땴땨땥 땯땢땪땥땣땴땳 땵땳땥땤 땩땮 땴땨땥 땣땡땬땬 땴땯 땴땨땥 땨땩땧땨딭땬땥땶땥땬 땰땬땯땴땴땩땮땧 땦땵땮땣땴땩땯땮딮
• 땭땡땩땮딽땳땴땲땩땮땧
땆땩땧땵땲땥 땴땩땴땬땥딬 땰땬땡땣땥땤 땡땴 땴땨땥 땴땯땰 땯땦 땴땨땥 땰땬땯땴 땩땮 땡 땬땡땲땧땥 땦땯땮땴딮
• 땳땵땢딽땳땴땲땩땮땧
땓땵땢딭땴땩땴땬땥딬 땰땬땡땣땥땤 땪땵땳땴 땢땥땬땯땷 땴땨땥 땸딭땡땸땩땳 땩땮 땡 땳땭땡땬땬땥땲 땦땯땮땴딮
제2절
Low-level plotting commands
땓땯땭땥땴땩땭땥땳 땴땨땥 땨땩땧땨딭땬땥땶땥땬 땰땬땯땴땴땩땮땧 땦땵땮땣땴땩땯땮땳 땤땯땮딧땴 땰땲땯땤땵땣땥 땥땸땡땣땴땬땹 땴땨땥 땫땩땮땤 땯땦 땰땬땯땴 땹땯땵
땤땥땳땩땲땥딮 땉땮 땴땨땩땳 땣땡땳땥딬 땬땯땷딭땬땥땶땥땬 땰땬땯땴땴땩땮땧 땣땯땭땭땡땮땤땳 땣땡땮 땢땥 땵땳땥땤 땴땯 땡땤땤 땥땸땴땲땡 땩땮땦땯땲땭땡땴땩땯땮
딨땳땵땣땨 땡땳 땰땯땩땮땴땳딬 땬땩땮땥땳 땯땲 땴땥땸땴딩 땴땯 땴땨땥 땣땵땲땲땥땮땴 땰땬땯땴딮
땓땯땭땥 땯땦 땴땨땥 땭땯땲땥 땵땳땥땦땵땬 땬땯땷딭땬땥땶땥땬 땰땬땯땴땴땩땮땧 땦땵땮땣땴땩땯땮땳 땡땲땥딺
• 땰땯땩땮땴땳딨땸딬 땹딩 땬땩땮땥땳딨땸딬 땹딩
땁땤땤땳 땰땯땩땮땴땳 땯땲 땣땯땮땮땥땣땴땥땤 땬땩땮땥땳 땴땯 땴땨땥 땣땵땲땲땥땮땴 땰땬땯땴딮 땰땬땯땴딨딩딧땳 땴땹땰땥딽 땡땲땧땵땭땥땮땴 땣땡땮
땡땬땳땯 땢땥 땰땡땳땳땥땤 땴땯 땴땨땥땳땥 땦땵땮땣땴땩땯땮땳 딨땡땮땤 땤땥땦땡땵땬땴땳 땴땯 딢땰딢 땦땯땲 땰땯땩땮땴땳딨딩 땡땮땤 딢땬딢 땦땯땲
땬땩땮땥땳딨딩딮딩
• 땴땥땸땴딨땸딬 땹딬 땬땡땢땥땬땳딬 딮딮딮딩
땁땤땤 땴땥땸땴 땴땯 땡 땰땬땯땴 땡땴 땰땯땩땮땴땳 땧땩땶땥땮 땢땹 땸딬 땹딮 땎땯땲땭땡땬땬땹 땬땡땢땥땬땳 땩땳 땡땮 땩땮땴땥땧땥땲 땯땲 땣땨땡땲딭
땡땣땴땥땲 땶땥땣땴땯땲 땩땮 땷땨땩땣땨 땣땡땳땥 땬땡땢땥땬땳땛땩땝 땩땳 땰땬땯땴땴땥땤 땡땴 땰땯땩땮땴 딨땸땛땩땝딬 땹땛땩땝딩딮 땔땨땥 땤땥땦땡땵땬땴 땩땳
딱딺땬땥땮땧땴땨딨땸딩딮 땎땯땴땥딺 땔땨땩땳 땦땵땮땣땴땩땯땮 땩땳 땯땦땴땥땮 땵땳땥땤 땩땮 땴땨땥 땳땥땱땵땥땮땣땥
> plot(x, y, type="n"); text(x, y, names)
딱따딴
그림 딱딷딮딵딺 땈땩땧땨딭땬땥땶땥땬 땰땬땯땴땳
딱따딵
땔땨땥 땧땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲 땴땹땰땥딽딢땮딢 땳땵땰땰땲땥땳땳땥땳 땴땨땥 땰땯땩땮땴땳 땢땵땴 땳땥땴땳 땵땰 땴땨땥 땡땸땥땳딬 땡땮땤
땴땨땥 땴땥땸땴딨딩 땦땵땮땣땴땩땯땮 땳땵땰땰땬땩땥땳 땳땰땥땣땩땡땬 땣땨땡땲땡땣땴땥땲땳딬 땡땳 땳땰땥땣땩딌땥땤 땢땹 땴땨땥 땣땨땡땲땡땣땴땥땲 땶땥땣땴땯땲
땮땡땭땥땳 땦땯땲 땴땨땥 땰땯땩땮땴땳딮
• 땡땢땬땩땮땥딨땡딬 땢딩딬 땡땢땬땩땮땥딨땨딽땹딩딬 땡땢땬땩땮땥딨땶딽땸딩딬 땡땢땬땩땮땥딨땬땭딮땯땢땪딩
땁땤땤땳 땡 땬땩땮땥 땯땦 땳땬땯땰땥 땢 땡땮땤 땩땮땴땥땲땣땥땰땴 땡 땴땯 땴땨땥 땣땵땲땲땥땮땴 땰땬땯땴딮 땨딽땹 땭땡땹 땢땥 땵땳땥땤 땴땯
땳땰땥땣땩땦땹 땹딭땣땯땯땲땤땩땮땡땴땥땳 땦땯땲 땴땨땥 땨땥땩땧땨땴땳 땯땦 땨땯땲땩땺땯땮땴땡땬 땬땩땮땥땳 땴땯 땧땯 땡땣땲땯땳땳 땡 땰땬땯땴딬 땡땮땤
땶딽땸 땳땩땭땩땬땡땲땬땹 땦땯땲 땴땨땥 땸딭땣땯땯땲땤땩땮땡땴땥땳 땦땯땲 땶땥땲땴땩땣땡땬 땬땩땮땥땳딮 땁땬땳땯 땬땭딮땯땢땪 땭땡땹 땢땥 땬땩땳땴 땷땩땴땨
땡 땣땯땥딎땣땩땥땮땴땳 땣땯땭땰땯땮땥땮땴 땯땦 땬땥땮땧땴땨 딲 딨땳땵땣땨 땡땳 땴땨땥 땲땥땳땵땬땴 땯땦 땭땯땤땥땬딭딌땴땴땩땮땧 땦땵땮땣땴땩땯땮땳딬딩
땷땨땩땣땨 땡땲땥 땴땡땫땥땮 땡땳 땡땮 땩땮땴땥땲땣땥땰땴 땡땮땤 땳땬땯땰땥딬 땩땮 땴땨땡땴 땯땲땤땥땲딮
• 땰땯땬땹땧땯땮딨땸딬 땹딬 딮딮딮딩
땄땲땡땷땳 땡 땰땯땬땹땧땯땮 땤땥딌땮땥땤 땢땹 땴땨땥 땯땲땤땥땲땥땤 땶땥땲땴땩땣땥땳 땩땮 딨땸딬 땹딩 땡땮땤 딨땯땰땴땩땯땮땡땬땬땹딩 땳땨땡땤땥
땩땴 땩땮 땷땩땴땨 땨땡땴땣땨 땬땩땮땥땳딬 땯땲 딌땬땬 땩땴 땩땦 땴땨땥 땧땲땡땰땨땩땣땳 땤땥땶땩땣땥 땡땬땬땯땷땳 땴땨땥 딌땬땬땩땮땧 땯땦 딌땧땵땲땥땳딮
• 땬땥땧땥땮땤딨땸딬 땹딬 땬땥땧땥땮땤딬 딮딮딮딩
땁땤땤땳 땡 땬땥땧땥땮땤 땴땯 땴땨땥 땣땵땲땲땥땮땴 땰땬땯땴 땡땴 땴땨땥 땳땰땥땣땩딌땥땤 땰땯땳땩땴땩땯땮딮 땐땬땯땴땴땩땮땧 땣땨땡땲땡땣땴땥땲땳딬
땬땩땮땥 땳땴땹땬땥땳딬 땣땯땬땯땲땳 땥땴땣딮딬 땡땲땥 땩땤땥땮땴땩딌땥땤 땷땩땴땨 땴땨땥 땬땡땢땥땬땳 땩땮 땴땨땥 땣땨땡땲땡땣땴땥땲 땶땥땣땴땯땲 땬땥땧땥땮땤딮
땁땴 땬땥땡땳땴 땯땮땥 땯땴땨땥땲 땡땲땧땵땭땥땮땴 땶 딨땡 땶땥땣땴땯땲 땴땨땥 땳땡땭땥 땬땥땮땧땴땨 땡땳 땬땥땧땥땮땤딩 땷땩땴땨 땴땨땥 땣땯땲땲땥딭
땳땰땯땮땤땩땮땧 땶땡땬땵땥땳 땯땦 땴땨땥 땰땬땯땴땴땩땮땧 땵땮땩땴 땭땵땳땴 땡땬땳땯 땢땥 땧땩땶땥땮딬 땡땳 땦땯땬땬땯땷땳딺 땬땥땧땥땮땤딨 딬 딌땬땬딽땶딩
땃땯땬땯땲땳 땦땯땲 딌땬땬땥땤 땢땯땸땥땳
– 땬땥땧땥땮땤딨 딬 땣땯땬딽땶딩 딺 땃땯땬땯땲땳 땩땮 땷땨땩땣땨 땰땯땩땮땴땳 땯땲 땬땩땮땥땳 땷땩땬땬 땢땥 땤땲땡땷땮
– 땬땥땧땥땮땤딨 딬 땬땴땹딽땶딩 딺 때땩땮땥 땳땴땹땬땥땳
– 땬땥땧땥땮땤딨 딬 땬땷땤딽땶딩 딺 때땩땮땥 땷땩땤땴땨땳
– 땬땥땧땥땮땤딨 딬 땰땣땨딽땶딩 딺 땐땬땯땴땴땩땮땧 땣땨땡땲땡땣땴땥땲땳 딨땣땨땡땲땡땣땴땥땲 땶땥땣땴땯땲딩
• 땴땩땴땬땥딨땭땡땩땮딬 땳땵땢딩
땁땤땤땳 땡 땴땩땴땬땥 땭땡땩땮 땴땯 땴땨땥 땴땯땰 땯땦 땴땨땥 땣땵땲땲땥땮땴 땰땬땯땴 땩땮 땡 땬땡땲땧땥 땦땯땮땴 땡땮땤 딨땯땰땴땩땯땮땡땬땬땹딩 땡
땳땵땢딭땴땩땴땬땥 땳땵땢 땡땴 땴땨땥 땢땯땴땴땯땭 땩땮 땡 땳땭땡땬땬땥땲 땦땯땮땴딮
• 땡땸땩땳딨땳땩땤땥딬 딮딮딮딩
땁땤땤땳 땡땮 땡땸땩땳 땴땯 땴땨땥 땣땵땲땲땥땮땴 땰땬땯땴 땯땮 땴땨땥 땳땩땤땥 땧땩땶땥땮 땢땹 땴땨땥 딌땲땳땴 땡땲땧땵땭땥땮땴 딨딱 땴땯 딴딬
땣땯땵땮땴땩땮땧 땣땬땯땣땫땷땩땳땥 땦땲땯땭 땴땨땥 땢땯땴땴땯땭딮딩 땏땴땨땥땲 땡땲땧땵땭땥땮땴땳 땣땯땮땴땲땯땬 땴땨땥 땰땯땳땩땴땩땯땮땩땮땧 땯땦
땴땨땥 땡땸땩땳 땷땩땴땨땩땮 땯땲 땢땥땳땩땤땥 땴땨땥 땰땬땯땴딬 땡땮땤 땴땩땣땫 땰땯땳땩땴땩땯땮땳 땡땮땤 땬땡땢땥땬땳딮 땕땳땥땦땵땬 땦땯땲 땡땤땤땩땮땧
땣땵땳땴땯땭 땡땸땥땳 땡땦땴땥땲 땣땡땬땬땩땮땧 땰땬땯땴딨딩 땷땩땴땨 땴땨땥 땡땸땥땳딽땆땁때땓땅 땡땲땧땵땭땥땮땴딮 때땯땷딭땬땥땶땥땬 땰땬땯땴땴땩땮땧
땦땵땮땣땴땩땯땮땳 땵땳땵땡땬땬땹 땲땥땱땵땩땲땥 땳땯땭땥 땰땯땳땩땴땩땯땮땩땮땧 땩땮땦땯땲땭땡땴땩땯땮 딨땥딮땧딮딬 땸 땡땮땤 땹 땣땯땯땲땤땩땮땡땴땥땳딩
딱따딶
땴땯 땤땥땴땥땲땭땩땮땥 땷땨땥땲땥 땴땯 땰땬땡땣땥 땴땨땥 땮땥땷 땰땬땯땴 땥땬땥땭땥땮땴땳딮 땃땯땯땲땤땩땮땡땴땥땳 땡땲땥 땧땩땶땥땮 땩땮 땴땥땲땭땳
땯땦 땵땳땥땲 땣땯땯땲땤땩땮땡땴땥땳 땷땨땩땣땨 땡땲땥 땤땥딌땮땥땤 땢땹 땴땨땥 땰땲땥땶땩땯땵땳 땨땩땧땨딭땬땥땶땥땬 땧땲땡땰땨땩땣땳 땣땯땭땭땡땮땤
땡땮땤 땡땲땥 땣땨땯땳땥땮 땢땡땳땥땤 땯땮 땴땨땥 땳땵땰땰땬땩땥땤 땤땡땴땡딮
땗땨땥땲땥 땸 땡땮땤 땹 땡땲땧땵땭땥땮땴땳 땡땲땥 땲땥땱땵땩땲땥땤딬 땩땴 땩땳 땡땬땳땯 땳땵딎땣땩땥땮땴 땴땯 땳땵땰땰땬땹 땡 땳땩땮땧땬땥 땡땲딭
땧땵땭땥땮땴 땢땥땩땮땧 땡 땬땩땳땴 땷땩땴땨 땥땬땥땭땥땮땴땳 땮땡땭땥땤 땸 땡땮땤 땹딮 땓땩땭땩땬땡땲땬땹 땡 땭땡땴땲땩땸 땷땩땴땨 땴땷땯
땣땯땬땵땭땮땳 땩땳 땡땬땳땯 땶땡땬땩땤 땩땮땰땵땴딮 땉땮 땴땨땩땳 땷땡땹 땦땵땮땣땴땩땯땮땳 땳땵땣땨 땡땳 땬땯땣땡땴땯땲딨딩 딨땳땥땥 땢땥땬땯땷딩
땭땡땹 땢땥 땵땳땥땤 땴땯 땳땰땥땣땩땦땹 땰땯땳땩땴땩땯땮땳 땯땮 땡 땰땬땯땴 땩땮땴땥땲땡땣땴땩땶땥땬땹딮
2.0.5
Mathematical annotation (수식의 삽입)
가끔은 그림에 수학기호나 수식을 넣고 싶은 경우가 있다딮 이런 경우 땒 에서는 땥땸땰땲땥땳땳땩땯땮딨딩함
수를 이용한다딮 예를 들어 다음은 이항분포함수를 그림의 메인타이틀에 넣는 코드이다딮
> text(x, y, expression(paste(bgroup("(", atop(n, x), ")"), p^x, q^{n-x})))
비슷한 기능을 하는 함수로 땰땬땯땴땭땡땴땨딨딩가 있는데 참고하기 바란다딮
> help(plotmath)
> example(plotmath)
> demo(plotmath)
제3절
Interacting with graphics
땒 땡땬땳땯 땰땲땯땶땩땤땥땳 땦땵땮땣땴땩땯땮땳 땷땨땩땣땨 땡땬땬땯땷 땵땳땥땲땳 땴땯 땥땸땴땲땡땣땴 땯땲 땡땤땤 땩땮땦땯땲땭땡땴땩땯땮 땴땯 땡 땰땬땯땴 땵땳땩땮땧
땡 땭땯땵땳땥딮 땔땨땥 땳땩땭땰땬땥땳땴 땯땦 땴땨땥땳땥 땩땳 땴땨땥 땬땯땣땡땴땯땲딨딩 땦땵땮땣땴땩땯땮딺
• 땬땯땣땡땴땯땲딨땮딬 땴땹땰땥딩
땗땡땩땴땳 땦땯땲 땴땨땥 땵땳땥땲 땴땯 땳땥땬땥땣땴 땬땯땣땡땴땩땯땮땳 땯땮 땴땨땥 땣땵땲땲땥땮땴 땰땬땯땴 땵땳땩땮땧 땴땨땥 땬땥땦땴 땭땯땵땳땥 땢땵땴딭
땴땯땮딮 땔땨땩땳 땣땯땮땴땩땮땵땥땳 땵땮땴땩땬 땮 딨땤땥땦땡땵땬땴 딵딱딲딩 땰땯땩땮땴땳 땨땡땶땥 땢땥땥땮 땳땥땬땥땣땴땥땤딬 땯땲 땡땮땯땴땨땥땲
땭땯땵땳땥 땢땵땴땴땯땮 땩땳 땰땲땥땳땳땥땤딮 땔땨땥 땴땹땰땥 땡땲땧땵땭땥땮땴 땡땬땬땯땷땳 땦땯땲 땰땬땯땴땴땩땮땧 땡땴 땴땨땥 땳땥땬땥땣땴땥땤
땰땯땩땮땴땳 땡땮땤 땨땡땳 땴땨땥 땳땡땭땥 땥딋땥땣땴 땡땳 땦땯땲 땨땩땧땨딭땬땥땶땥땬 땧땲땡땰땨땩땣땳 땣땯땭땭땡땮땤땳딻 땴땨땥 땤땥땦땡땵땬땴 땩땳
땮땯 땰땬땯땴땴땩땮땧딮 땬땯땣땡땴땯땲딨딩 땲땥땴땵땲땮땳 땴땨땥 땬땯땣땡땴땩땯땮땳 땯땦 땴땨땥 땰땯땩땮땴땳 땳땥땬땥땣땴땥땤 땡땳 땡 땬땩땳땴 땷땩땴땨 땴땷땯
땣땯땭땰땯땮땥땮땴땳 땸 땡땮땤 땹딮 땬땯땣땡땴땯땲딨딩 땩땳 땵땳땵땡땬땬땹 땣땡땬땬땥땤 땷땩땴땨 땮땯 땡땲땧땵땭땥땮땴땳딮 땉땴 땩땳 땰땡땲땴땩땣땵딭
땬땡땲땬땹 땵땳땥땦땵땬 땦땯땲 땩땮땴땥땲땡땣땴땩땶땥땬땹 땳땥땬땥땣땴땩땮땧 땰땯땳땩땴땩땯땮땳 땦땯땲 땧땲땡땰땨땩땣 땥땬땥땭땥땮땴땳 땳땵땣땨 땡땳 땬땥땧땥땮땤땳
땯땲 땬땡땢땥땬땳 땷땨땥땮 땩땴 땩땳 땤땩딎땣땵땬땴 땴땯 땣땡땬땣땵땬땡땴땥 땩땮 땡땤땶땡땮땣땥 땷땨땥땲땥 땴땨땥 땧땲땡땰땨땩땣 땳땨땯땵땬땤 땢땥
땰땬땡땣땥땤딮 땆땯땲 땥땸땡땭땰땬땥딬 땴땯 땰땬땡땣땥 땳땯땭땥 땩땮땦땯땲땭땡땴땩땶땥 땴땥땸땴 땮땥땡땲 땡땮 땯땵땴땬땹땩땮땧 땰땯땩땮땴딬 땴땨땥
땣땯땭땭땡땮땤
> text(locator(1), "Outlier", adj=0)
딱따딷
땭땡땹 땢땥 땵땳땥땦땵땬딮 딨땬땯땣땡땴땯땲딨딩 땷땩땬땬 땢땥 땩땧땮땯땲땥땤 땩땦 땴땨땥 땣땵땲땲땥땮땴 땤땥땶땩땣땥딬 땳땵땣땨 땡땳 땰땯땳땴땳땣땲땩땰땴
땤땯땥땳 땮땯땴 땳땵땰땰땯땲땴 땩땮땴땥땲땡땣땴땩땶땥 땰땯땩땮땴땩땮땧딮딩
• 땩땤땥땮땴땩땦땹딨땸딬 땹딬 땬땡땢땥땬땳딩
땁땬땬땯땷 땴땨땥 땵땳땥땲 땴땯 땨땩땧땨땬땩땧땨땴 땡땮땹 땯땦 땴땨땥 땰땯땩땮땴땳 땤땥딌땮땥땤 땢땹 땸 땡땮땤 땹 딨땵땳땩땮땧 땴땨땥 땬땥땦땴
땭땯땵땳땥 땢땵땴땴땯땮딩 땢땹 땰땬땯땴땴땩땮땧 땴땨땥 땣땯땲땲땥땳땰땯땮땤땩땮땧 땣땯땭땰땯땮땥땮땴 땯땦 땬땡땢땥땬땳 땮땥땡땲땢땹 딨땯땲 땴땨땥
땩땮땤땥땸 땮땵땭땢땥땲 땯땦 땴땨땥 땰땯땩땮땴 땩땦 땬땡땢땥땬땳 땩땳 땡땢땳땥땮땴딩딮 땒땥땴땵땲땮땳 땴땨땥 땩땮땤땩땣땥땳 땯땦 땴땨땥 땳땥땬땥땣땴땥땤
땰땯땩땮땴땳 땷땨땥땮 땡땮땯땴땨땥땲 땢땵땴땴땯땮 땩땳 땰땲땥땳땳땥땤딮 땓땯땭땥땴땩땭땥땳 땷땥 땷땡땮땴 땴땯 땩땤땥땮땴땩땦땹 땰땡땲땴땩땣땵땬땡땲
땰땯땩땮땴땳 땯땮 땡 땰땬땯땴딬 땲땡땴땨땥땲 땴땨땡땮 땴땨땥땩땲 땰땯땳땩땴땩땯땮땳딮 땆땯땲 땥땸땡땭땰땬땥딬 땷땥 땭땡땹 땷땩땳땨 땴땨땥 땵땳땥땲
땴땯 땳땥땬땥땣땴 땳땯땭땥 땯땢땳땥땲땶땡땴땩땯땮 땯땦 땩땮땴땥땲땥땳땴 땦땲땯땭 땡 땧땲땡땰땨땩땣땡땬 땤땩땳땰땬땡땹 땡땮땤 땴땨땥땮 땭땡땮땩땰땵땬땡땴땥
땴땨땡땴 땯땢땳땥땲땶땡땴땩땯땮 땩땮 땳땯땭땥 땷땡땹딮 땇땩땶땥땮 땡 땮땵땭땢땥땲 땯땦 딨땸딬 땹딩 땣땯땯땲땤땩땮땡땴땥땳 땩땮 땴땷땯 땮땵땭땥땲땩땣
땶땥땣땴땯땲땳 땸 땡땮땤 땹딬 땷땥 땣땯땵땬땤 땵땳땥 땴땨땥 땩땤땥땮땴땩땦땹딨딩 땦땵땮땣땴땩땯땮 땡땳 땦땯땬땬땯땷땳딺
> plot(x, y)
> identify(x, y)
땔땨땥 땩땤땥땮땴땩땦땹딨딩 땦땵땮땣땴땩땯땮땳 땰땥땲땦땯땲땭땳 땮땯 땰땬땯땴땴땩땮땧 땩땴땳땥땬땦딬 땢땵땴 땳땩땭땰땬땹 땡땬땬땯땷땳 땴땨땥 땵땳땥땲 땴땯
땭땯땶땥 땴땨땥 땭땯땵땳땥 땰땯땩땮땴땥땲 땡땮땤 땣땬땩땣땫 땴땨땥 땬땥땦땴 땭땯땵땳땥 땢땵땴땴땯땮 땮땥땡땲 땡 땰땯땩땮땴딮 땉땦 땴땨땥땲땥 땩땳
땡 땰땯땩땮땴 땮땥땡땲 땴땨땥 땭땯땵땳땥 땰땯땩땮땴땥땲 땩땴 땷땩땬땬 땢땥 땭땡땲땫땥땤 땷땩땴땨 땩땴땳 땩땮땤땥땸 땮땵땭땢땥땲 딨땴땨땡땴 땩땳딬
땩땴땳 땰땯땳땩땴땩땯땮 땩땮 땴땨땥 땸딯땹 땶땥땣땴땯땲땳딩 땰땬땯땴땴땥땤 땮땥땡땲땢땹딮 땁땬땴땥땲땮땡땴땩땶땥땬땹딬 땹땯땵 땣땯땵땬땤 땵땳땥 땳땯땭땥
땩땮땦땯땲땭땡땴땩땶땥 땳땴땲땩땮땧 딨땳땵땣땨 땡땳 땡 땣땡땳땥 땮땡땭땥딩 땡땳 땡 땨땩땧땨땬땩땧땨땴 땢땹 땵땳땩땮땧 땴땨땥 땬땡땢땥땬땳 땡땲땧땵딭
땭땥땮땴 땴땯 땩땤땥땮땴땩땦땹딨딩딬 땯땲 땤땩땳땡땢땬땥 땭땡땲땫땩땮땧 땡땬땴땯땧땥땴땨땥땲 땷땩땴땨 땴땨땥 땰땬땯땴 딽 땆땁때땓땅 땡땲땧땵땭땥땮땴딮
땗땨땥땮 땴땨땥 땰땲땯땣땥땳땳 땩땳 땴땥땲땭땩땮땡땴땥땤 딨땳땥땥 땡땢땯땶땥딩딬 땩땤땥땮땴땩땦땹딨딩 땲땥땴땵땲땮땳 땴땨땥 땩땮땤땩땣땥땳 땯땦 땴땨땥
땳땥땬땥땣땴땥땤 땰땯땩땮땴땳딻 땹땯땵 땣땡땮 땵땳땥 땴땨땥땳땥 땩땮땤땩땣땥땳 땴땯 땥땸땴땲땡땣땴 땴땨땥 땳땥땬땥땣땴땥땤 땰땯땩땮땴땳 땦땲땯땭 땴땨땥
땯땲땩땧땩땮땡땬 땶땥땣땴땯땲땳 땸 땡땮땤 땹딮
제4절
Using graphics parameters
땗땨땥땮 땣땲땥땡땴땩땮땧 땧땲땡땰땨땩땣땳딬 땰땡땲땴땩땣땵땬땡땲땬땹 땦땯땲 땰땲땥땳땥땮땴땡땴땩땯땮 땯땲 땰땵땢땬땩땣땡땴땩땯땮 땰땵땲땰땯땳땥땳딬 땒딧땳 땤땥딭
땦땡땵땬땴땳 땤땯 땮땯땴 땡땬땷땡땹땳 땰땲땯땤땵땣땥 땥땸땡땣땴땬땹 땴땨땡땴 땷땨땩땣땨 땩땳 땲땥땱땵땩땲땥땤딮 땙땯땵 땣땡땮딬 땨땯땷땥땶땥땲딬 땣땵땳딭
땴땯땭땩땺땥 땡땬땭땯땳땴 땥땶땥땲땹 땡땳땰땥땣땴 땯땦 땴땨땥 땤땩땳땰땬땡땹 땵땳땩땮땧 땧땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲땳딮 땒 땭땡땩땮땴땡땩땮땳 땡 땬땩땳땴
땯땦 땡 땬땡땲땧땥 땮땵땭땢땥땲 땯땦 땧땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲땳 땷땨땩땣땨 땣땯땮땴땲땯땬 땴땨땩땮땧땳 땳땵땣땨 땡땳 땬땩땮땥 땳땴땹땬땥딬 땣땯땬땯땲땳딬
딌땧땵땲땥 땡땲땲땡땮땧땥땭땥땮땴 땡땮땤 땴땥땸땴 땪땵땳땴땩딌땣땡땴땩땯땮 땡땭땯땮땧 땭땡땮땹 땯땴땨땥땲땳딮 땅땶땥땲땹 땧땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲
땨땡땳 땡 땮땡땭땥 딨땳땵땣땨 땡땳 땠땣땯땬딧딬 땷땨땩땣땨 땣땯땮땴땲땯땬땳 땣땯땬땯땲땳딬딩 땡땮땤 땡 땶땡땬땵땥 딨땡 땣땯땬땯땲 땮땵땭땢땥땲딬 땦땯땲 땥땸딭
땡땭땰땬땥딮딩
땁 땳땥땰땡땲땡땴땥 땬땩땳땴 땯땦 땧땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲땳 땩땳 땭땡땩땮땴땡땩땮땥땤 땦땯땲 땥땡땣땨 땡땣땴땩땶땥 땤땥땶땩땣땥딬 땡땮땤 땥땡땣땨
땤땥땶땩땣땥 땨땡땳 땡 땤땥땦땡땵땬땴 땳땥땴 땯땦 땰땡땲땡땭땥땴땥땲땳 땷땨땥땮 땩땮땩땴땩땡땬땩땺땥땤딮 땇땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲땳 땣땡땮 땢땥 땳땥땴
딱따딸
땩땮 땴땷땯 땷땡땹땳딺 땥땩땴땨땥땲 땰땥땲땭땡땮땥땮땴땬땹딬 땡딋땥땣땴땩땮땧 땡땬땬 땧땲땡땰땨땩땣땳 땦땵땮땣땴땩땯땮땳 땷땨땩땣땨 땡땣땣땥땳땳 땴땨땥 땣땵땲땲땥땮땴
땤땥땶땩땣땥딻 땯땲 땴땥땭땰땯땲땡땲땩땬땹딬 땡딋땥땣땴땩땮땧 땯땮땬땹 땡 땳땩땮땧땬땥 땧땲땡땰땨땩땣땳 땦땵땮땣땴땩땯땮 땣땡땬땬딮
4.0.6
Permanent changes: The par() function
땔땨땥 땰땡땲딨딩 땦땵땮땣땴땩땯땮 땩땳 땵땳땥땤 땴땯 땡땣땣땥땳땳 땡땮땤 땭땯땤땩땦땹 땴땨땥 땬땩땳땴 땯땦 땧땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲땳 땦땯땲 땴땨땥
땣땵땲땲땥땮땴 땧땲땡땰땨땩땣땳 땤땥땶땩땣땥딮
• 땰땡땲딨딩
땗땩땴땨땯땵땴 땡땲땧땵땭땥땮땴땳딬 땲땥땴땵땲땮땳 땡 땬땩땳땴 땯땦 땡땬땬 땧땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲땳 땡땮땤 땴땨땥땩땲 땶땡땬땵땥땳 땦땯땲
땴땨땥 땣땵땲땲땥땮땴 땤땥땶땩땣땥딮
• 땰땡땲딨땣딨딢땣땯땬딢딬 딢땬땴땹딢딩딩
땗땩땴땨 땡 땣땨땡땲땡땣땴땥땲 땶땥땣땴땯땲 땡땲땧땵땭땥땮땴딬 땲땥땴땵땲땮땳 땯땮땬땹 땴땨땥 땮땡땭땥땤 땧땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲땳
딨땡땧땡땩땮딬 땡땳 땡 땬땩땳땴딮딩
• 땰땡땲딨땣땯땬딽딴딬 땬땴땹딽딲딩
땗땩땴땨 땮땡땭땥땤 땡땲땧땵땭땥땮땴땳 딨땯땲 땡 땳땩땮땧땬땥 땬땩땳땴 땡땲땧땵땭땥땮땴딩딬 땳땥땴땳 땴땨땥 땶땡땬땵땥땳 땯땦 땴땨땥 땮땡땭땥땤
땧땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲땳딬 땡땮땤 땲땥땴땵땲땮땳 땴땨땥 땯땲땩땧땩땮땡땬 땶땡땬땵땥땳 땯땦 땴땨땥 땰땡땲땡땭땥땴땥땲땳 땡땳 땡 땬땩땳땴딮
땓땥땴땴땩땮땧 땧땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲땳 땷땩땴땨 땴땨땥 땰땡땲딨딩 땦땵땮땣땴땩땯땮 땣땨땡땮땧땥땳 땴땨땥 땶땡땬땵땥 땯땦 땴땨땥 땰땡딭
땲땡땭땥땴땥땲땳 땰땥땲땭땡땮땥땮땴땬땹딬 땩땮 땴땨땥 땳땥땮땳땥 땴땨땡땴 땡땬땬 땦땵땴땵땲땥 땣땡땬땬땳 땴땯 땧땲땡땰땨땩땣땳 땦땵땮땣땴땩땯땮땳 딨땯땮 땴땨땥
땣땵땲땲땥땮땴 땤땥땶땩땣땥딩 땷땩땬땬 땢땥 땡딋땥땣땴땥땤 땢땹 땴땨땥 땮땥땷 땶땡땬땵땥딮 땙땯땵 땣땡땮 땴땨땩땮땫 땯땦 땳땥땴땴땩땮땧 땧땲땡땰땨땩땣땳
땰땡땲땡땭땥땴땥땲땳 땩땮 땴땨땩땳 땷땡땹 땡땳 땳땥땴땴땩땮땧 땜땤땥땦땡땵땬땴딢 땶땡땬땵땥땳 땦땯땲 땴땨땥 땰땡땲땡땭땥땴땥땲땳딬 땷땨땩땣땨 땷땩땬땬
땢땥 땵땳땥땤 땢땹 땡땬땬 땧땲땡땰땨땩땣땳 땦땵땮땣땴땩땯땮땳 땵땮땬땥땳땳 땡땮 땡땬땴땥땲땮땡땴땩땶땥 땶땡땬땵땥 땩땳 땧땩땶땥땮딮
땎땯땴땥 땴땨땡땴 땣땡땬땬땳 땴땯 땰땡땲딨딩 땡땬땷땡땹땳 땡딋땥땣땴 땴땨땥 땧땬땯땢땡땬 땶땡땬땵땥땳 땯땦 땧땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲땳딬 땥땶땥땮
땷땨땥땮 땰땡땲딨딩 땩땳 땣땡땬땬땥땤 땦땲땯땭 땷땩땴땨땩땮 땡 땦땵땮땣땴땩땯땮딮 땔땨땩땳 땩땳 땯땦땴땥땮 땵땮땤땥땳땩땲땡땢땬땥 땢땥땨땡땶땩땯땲딿땵땳땵땡땬땬땹
땷땥 땷땡땮땴 땴땯 땳땥땴 땳땯땭땥 땧땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲땳딬 땤땯 땳땯땭땥 땰땬땯땴땴땩땮땧딬 땡땮땤 땴땨땥땮 땲땥땳땴땯땲땥 땴땨땥 땯땲땩땧땩땮땡땬
땶땡땬땵땥땳 땳땯 땡땳 땮땯땴 땴땯 땡딋땥땣땴 땴땨땥 땵땳땥땲딧땳 땒 땳땥땳땳땩땯땮딮 땙땯땵 땣땡땮 땲땥땳땴땯땲땥 땴땨땥 땩땮땩땴땩땡땬 땶땡땬땵땥땳 땢땹 땳땡땶땩땮땧
땴땨땥 땲땥땳땵땬땴 땯땦 땰땡땲딨딩 땷땨땥땮 땭땡땫땩땮땧 땣땨땡땮땧땥땳딬 땡땮땤 땲땥땳땴땯땲땩땮땧 땴땨땥 땩땮땩땴땩땡땬 땶땡땬땵땥땳 땷땨땥땮 땰땬땯땴땴땩땮땧
땩땳 땣땯땭땰땬땥땴땥딮
> oldpar <- par(col=4, lty=2)
... plotting commands ...
> par(oldpar)
땔땯 땳땡땶땥 땡땮땤 땲땥땳땴땯땲땥 땡땬땬 땳땥땴땴땡땢땬땥딲딳 땧땲땡땰땨땩땣땡땬 땰땡땲땡땭땥땴땥땲땳 땵땳땥
> oldpar <- par(no.readonly=TRUE)
... plotting commands ...
> par(oldpar)
딱따딹
제5절
Graphics parameters list
땔땨땥 땦땯땬땬땯땷땩땮땧 땳땥땣땴땩땯땮땳 땤땥땴땡땩땬 땭땡땮땹 땯땦 땴땨땥 땣땯땭땭땯땮땬땹딭땵땳땥땤 땧땲땡땰땨땩땣땡땬 땰땡땲땡땭땥땴땥땲땳딮 땔땨땥 땒
땨땥땬땰 땤땯땣땵땭땥땮땴땡땴땩땯땮 땦땯땲 땴땨땥 땰땡땲딨딩 땦땵땮땣땴땩땯땮 땰땲땯땶땩땤땥땳 땡 땭땯땲땥 땣땯땮땣땩땳땥 땳땵땭땭땡땲땹딻 땴땨땩땳 땩땳 땰땲땯딭
땶땩땤땥땤 땡땳 땡 땳땯땭땥땷땨땡땴 땭땯땲땥 땤땥땴땡땩땬땥땤 땡땬땴땥땲땮땡땴땩땶땥딮
땇땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲땳 땷땩땬땬 땢땥 땰땲땥땳땥땮땴땥땤 땩땮 땴땨땥 땦땯땬땬땯땷땩땮땧 땦땯땲땭딺
name=value
땁 땤땥땳땣땲땩땰땴땩땯땮 땯땦 땴땨땥 땰땡땲땡땭땥땴땥땲딧땳 땥딋땥땣땴딮 땮땡땭땥 땩땳 땴땨땥 땮땡땭땥 땯땦 땴땨땥 땰땡땲땡땭땥땴땥땲딬 땴땨땡땴 땩땳딬
땴땨땥 땡땲땧땵땭땥땮땴 땮땡땭땥 땴땯 땵땳땥 땩땮 땣땡땬땬땳 땴땯 땰땡땲딨딩 땯땲 땡 땧땲땡땰땨땩땣땳 땦땵땮땣땴땩땯땮딮 땶땡땬땵땥 땩땳 땡 땴땹땰땩땣땡땬 땶땡땬땵땥
땹땯땵 땭땩땧땨땴 땵땳땥 땷땨땥땮 땳땥땴땴땩땮땧 땴땨땥 땰땡땲땡땭땥땴땥땲딮 땎땯땴땥 땴땨땡땴 땡땸땥땳 땩땳 땮땯땴 땡 땧땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲
땢땵땴 땡땮 땡땲땧땵땭땥땮땴 땴땯 땡 땦땥땷 땰땬땯땴 땭땥땴땨땯땤땳딺 땳땥땥 땸땡땸땴 땡땮땤 땹땡땸땴딮
5.0.7
Graphical elements
땒 땰땬땯땴땳 땡땲땥 땭땡땤땥 땵땰 땯땦 땰땯땩땮땴땳딬 땬땩땮땥땳딬 땴땥땸땴 땡땮땤 땰땯땬땹땧땯땮땳 딨딌땬땬땥땤 땲땥땧땩땯땮땳딮딩 땇땲땡땰땨땩땣땡땬 땰땡딭
땲땡땭땥땴땥땲땳 땥땸땩땳땴 땷땨땩땣땨 땣땯땮땴땲땯땬 땨땯땷 땴땨땥땳땥 땧땲땡땰땨땩땣땡땬 땥땬땥땭땥땮땴땳 땡땲땥 땤땲땡땷땮딬 땡땳 땦땯땬땬땯땷땳딺
pch="+"
땃땨땡땲땡땣땴땥땲 땴땯 땢땥 땵땳땥땤 땦땯땲 땰땬땯땴땴땩땮땧 땰땯땩땮땴땳딮 땔땨땥 땤땥땦땡땵땬땴 땶땡땲땩땥땳 땷땩땴땨 땧땲땡땰땨땩땣땳 땤땲땩땶땥땲땳딬
땢땵땴 땩땴 땩땳 땵땳땵땡땬땬땹 땡 땣땩땲땣땬땥딮 땐땬땯땴땴땥땤 땰땯땩땮땴땳 땴땥땮땤 땴땯 땡땰땰땥땡땲 땳땬땩땧땨땴땬땹 땡땢땯땶땥 땯땲 땢땥땬땯땷 땴땨땥 땡땰딭
땰땲땯땰땲땩땡땴땥 땰땯땳땩땴땩땯땮 땵땮땬땥땳땳 땹땯땵 땵땳땥 딢딮딢 땡땳 땴땨땥 땰땬땯땴땴땩땮땧 땣땨땡땲땡땣땴땥땲딬 땷땨땩땣땨 땰땲땯땤땵땣땥땳 땣땥땮땴땥땲땥땤
땰땯땩땮땴땳딮
pch=4
땗땨땥땮 땰땣땨 땩땳 땧땩땶땥땮 땡땳 땡땮 땩땮땴땥땧땥땲 땢땥땴땷땥땥땮 따 땡땮땤 딲딵 땩땮땣땬땵땳땩땶땥딬 땡 땳땰땥땣땩땡땬땩땺땥땤 땰땬땯땴땴땩땮땧
땳땹땭땢땯땬 땩땳 땰땲땯땤땵땣땥땤딮 땔땯 땳땥땥 땷땨땡땴 땴땨땥 땳땹땭땢땯땬땳 땡땲땥딬 땵땳땥 땴땨땥 땣땯땭땭땡땮땤
> legend(locator(1), as.character(0:25), pch = 0:25)
땔땨땯땳땥 땦땲땯땭 딲딱 땴땯 딲딵 땭땡땹 땡땰땰땥땡땲 땴땯 땤땵땰땬땩땣땡땴땥 땥땡땲땬땩땥땲 땳땹땭땢땯땬땳딬 땢땵땴 땣땡땮 땢땥 땣땯땬땯땵땲땥땤
땩땮 땤땩딋땥땲땥땮땴 땷땡땹땳딺 땳땥땥 땴땨땥 땨땥땬땰 땯땮 땰땯땩땮땴땳 땡땮땤 땩땴땳 땥땸땡땭땰땬땥땳딮
땉땮 땡땤땤땩땴땩땯땮딬 땰땣땨 땣땡땮 땢땥 땡 땣땨땡땲땡땣땴땥땲 땯땲 땡 땮땵땭땢땥땲 땩땮 땴땨땥 땲땡땮땧땥 딳딲딺딲딵딵 땲땥땰땲땥땳땥땮땴땩땮땧 땡
땣땨땡땲땡땣땴땥땲 땩땮 땴땨땥 땣땵땲땲땥땮땴 땦땯땮땴딮
lty=2
때땩땮땥 땴땹땰땥땳딮 땁땬땴땥땲땮땡땴땩땶땥 땬땩땮땥 땳땴땹땬땥땳 땡땲땥 땮땯땴 땳땵땰땰땯땲땴땥땤 땯땮 땡땬땬 땧땲땡땰땨땩땣땳 땤땥땶땩땣땥땳 딨땡땮땤 땶땡땲땹
땯땮 땴땨땯땳땥 땴땨땡땴 땤땯딩 땢땵땴 땬땩땮땥 땴땹땰땥 딱 땩땳 땡땬땷땡땹땳 땡 땳땯땬땩땤 땬땩땮땥딬 땬땩땮땥 땴땹땰땥 따 땩땳 땡땬땷땡땹땳 땩땮땶땩땳땩땢땬땥딬
땡땮땤 땬땩땮땥 땴땹땰땥땳 딲 땡땮땤 땯땮땷땡땲땤땳 땡땲땥 땤땯땴땴땥땤 땯땲 땤땡땳땨땥땤 땬땩땮땥땳딬 땯땲 땳땯땭땥 땣땯땭땢땩땮땡땴땩땯땮 땯땦 땢땯땴땨딮
딱딱따
lwd=2
때땩땮땥 땷땩땤땴땨땳딮 땄땥땳땩땲땥땤 땷땩땤땴땨 땯땦 땬땩땮땥땳딬 땩땮 땭땵땬땴땩땰땬땥땳 땯땦 땴땨땥 땜땳땴땡땮땤땡땲땤딢 땬땩땮땥 땷땩땤땴땨딮 땁딋땥땣땴땳
땡땸땩땳 땬땩땮땥땳 땡땳 땷땥땬땬 땡땳 땬땩땮땥땳 땤땲땡땷땮 땷땩땴땨 땬땩땮땥땳딨딩딬 땥땴땣딮 땎땯땴 땡땬땬 땤땥땶땩땣땥땳 땳땵땰땰땯땲땴 땴땨땩땳딬 땡땮땤 땳땯땭땥
땨땡땶땥 땲땥땳땴땲땩땣땴땩땯땮땳 땯땮 땴땨땥 땷땩땤땴땨땳 땴땨땡땴 땣땡땮 땢땥 땵땳땥땤딮
col=2
땃땯땬땯땲땳 땴땯 땢땥 땵땳땥땤 땦땯땲 땰땯땩땮땴땳딬 땬땩땮땥땳딬 땴땥땸땴딬 딌땬땬땥땤 땲땥땧땩땯땮땳 땡땮땤 땩땭땡땧땥땳딮 땁 땮땵땭땢땥땲 땦땲땯땭
땴땨땥 땣땵땲땲땥땮땴 땰땡땬땥땴땴땥 딨땳땥땥 딿땰땡땬땥땴땴땥딩 땯땲 땡 땮땡땭땥땤 땣땯땬땯땵땲딮
col.axis
col.lab
col.main
col.sub
땔땨땥 땣땯땬땯땲 땴땯 땢땥 땵땳땥땤 땦땯땲 땡땸땩땳 땡땮땮땯땴땡땴땩땯땮딬 땸 땡땮땤 땹 땬땡땢땥땬땳딬 땭땡땩땮 땡땮땤 땳땵땢딭땴땩땴땬땥땳딬 땲땥땳땰땥땣딭
땴땩땶땥땬땹딮
font=2
땁땮 땩땮땴땥땧땥땲 땷땨땩땣땨 땳땰땥땣땩딌땥땳 땷땨땩땣땨 땦땯땮땴 땴땯 땵땳땥 땦땯땲 땴땥땸땴딮 땉땦 땰땯땳땳땩땢땬땥딬 땤땥땶땩땣땥 땤땲땩땶땥땲땳 땡땲딭
땲땡땮땧땥 땳땯 땴땨땡땴 딱 땣땯땲땲땥땳땰땯땮땤땳 땴땯 땰땬땡땩땮 땴땥땸땴딬 딲 땴땯 땢땯땬땤 땦땡땣땥딬 딳 땴땯 땩땴땡땬땩땣딬 딴 땴땯 땢땯땬땤 땩땴땡땬땩땣 땡땮땤
딵 땴땯 땡 땳땹땭땢땯땬 땦땯땮땴 딨땷땨땩땣땨 땩땮땣땬땵땤땥 땇땲땥땥땫 땬땥땴땴땥땲땳딩딮
font.axis
font.lab
font.main
font.sub
땔땨땥 땦땯땮땴 땴땯 땢땥 땵땳땥땤 땦땯땲 땡땸땩땳 땡땮땮땯땴땡땴땩땯땮딬 땸 땡땮땤 땹 땬땡땢땥땬땳딬 땭땡땩땮 땡땮땤 땳땵땢딭땴땩땴땬땥땳딬 땲땥땳땰땥땣딭
땴땩땶땥땬땹딮
adj=-0.1
땊땵땳땴땩딌땣땡땴땩땯땮 땯땦 땴땥땸땴 땲땥땬땡땴땩땶땥 땴땯 땴땨땥 땰땬땯땴땴땩땮땧 땰땯땳땩땴땩땯땮딮 따 땭땥땡땮땳 땬땥땦땴 땪땵땳땴땩땦땹딬 딱 땭땥땡땮땳
땲땩땧땨땴 땪땵땳땴땩땦땹 땡땮땤 따딮딵 땭땥땡땮땳 땴땯 땣땥땮땴땥땲 땨땯땲땩땺땯땮땴땡땬땬땹 땡땢땯땵땴 땴땨땥 땰땬땯땴땴땩땮땧 땰땯땳땩땴땩땯땮딮 땔땨땥 땡땣땴땵땡땬
땶땡땬땵땥 땩땳 땴땨땥 땰땲땯땰땯땲땴땩땯땮 땯땦 땴땥땸땴 땴땨땡땴 땡땰땰땥땡땲땳 땴땯 땴땨땥 땬땥땦땴 땯땦 땴땨땥 땰땬땯땴땴땩땮땧 땰땯땳땩땴땩땯땮딬 땳땯 땡 땶땡땬땵땥
땯땦 딭따딮딱 땬땥땡땶땥땳 땡 땧땡땰 땯땦 딱따딥 땯땦 땴땨땥 땴땥땸땴 땷땩땤땴땨 땢땥땴땷땥땥땮 땴땨땥 땴땥땸땴 땡땮땤 땴땨땥 땰땬땯땴땴땩땮땧 땰땯땳땩땴땩땯땮딮
cex=1.5
딱딱딱
땃땨땡땲땡땣땴땥땲 땥땸땰땡땮땳땩땯땮딮 땔땨땥 땶땡땬땵땥 땩땳 땴땨땥 땤땥땳땩땲땥땤 땳땩땺땥 땯땦 땴땥땸땴 땣땨땡땲땡땣땴땥땲땳 딨땩땮땣땬땵땤땩땮땧 땰땬땯땴딭
땴땩땮땧 땣땨땡땲땡땣땴땥땲땳딩 땲땥땬땡땴땩땶땥 땴땯 땴땨땥 땤땥땦땡땵땬땴 땴땥땸땴 땳땩땺땥딮
cex.axis
cex.lab
cex.main
cex.sub
땔땨땥 땣땨땡땲땡땣땴땥땲 땥땸땰땡땮땳땩땯땮 땴땯 땢땥 땵땳땥땤 땦땯땲 땡땸땩땳 땡땮땮땯땴땡땴땩땯땮딬 땸 땡땮땤 땹 땬땡땢땥땬땳딬 땭땡땩땮 땡땮땤
땳땵땢딭땴땩땴땬땥땳딬 땲땥땳땰땥땣땴땩땶땥땬땹딮
5.0.8
Axes and tick marks
땍땡땮땹 땯땦 땒딧땳 땨땩땧땨딭땬땥땶땥땬 땰땬땯땴땳 땨땡땶땥 땡땸땥땳딬 땡땮땤 땹땯땵 땣땡땮 땣땯땮땳땴땲땵땣땴 땡땸땥땳 땹땯땵땲땳땥땬땦 땷땩땴땨 땴땨땥 땬땯땷딭
땬땥땶땥땬 땡땸땩땳딨딩 땧땲땡땰땨땩땣땳 땦땵땮땣땴땩땯땮딮 땁땸땥땳 땨땡땶땥 땴땨땲땥땥 땭땡땩땮 땣땯땭땰땯땮땥땮땴땳딺 땴땨땥 땡땸땩땳 땬땩땮땥 딨땬땩땮땥 땳땴땹땬땥
땣땯땮땴땲땯땬땬땥땤 땢땹 땴땨땥 땬땴땹 땧땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲딩딬 땴땨땥 땴땩땣땫 땭땡땲땫땳 딨땷땨땩땣땨 땭땡땲땫 땯딋 땵땮땩땴 땤땩땶땩땳땩땯땮땳
땡땬땯땮땧 땴땨땥 땡땸땩땳 땬땩땮땥딩 땡땮땤 땴땨땥 땴땩땣땫 땬땡땢땥땬땳 딨땷땨땩땣땨 땭땡땲땫 땴땨땥 땵땮땩땴땳딮딩 땔땨땥땳땥 땣땯땭땰땯땮땥땮땴땳 땣땡땮
땢땥 땣땵땳땴땯땭땩땺땥땤 땷땩땴땨 땴땨땥 땦땯땬땬땯땷땩땮땧 땧땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲땳딮
lab=c(5, 7, 12)
땔땨땥 딌땲땳땴 땴땷땯 땮땵땭땢땥땲땳 땡땲땥 땴땨땥 땤땥땳땩땲땥땤 땮땵땭땢땥땲 땯땦 땴땩땣땫 땩땮땴땥땲땶땡땬땳 땯땮 땴땨땥 땸 땡땮땤 땹 땡땸땥땳
땲땥땳땰땥땣땴땩땶땥땬땹딮 땔땨땥 땴땨땩땲땤 땮땵땭땢땥땲 땩땳 땴땨땥 땤땥땳땩땲땥땤 땬땥땮땧땴땨 땯땦 땡땸땩땳 땬땡땢땥땬땳딬 땩땮 땣땨땡땲땡땣땴땥땲땳 딨땩땮땣땬땵땤딭
땩땮땧 땴땨땥 땤땥땣땩땭땡땬 땰땯땩땮땴딮딩 땃땨땯땯땳땩땮땧 땡 땴땯땯딭땳땭땡땬땬 땶땡땬땵땥 땦땯땲 땴땨땩땳 땰땡땲땡땭땥땴땥땲 땭땡땹 땲땥땳땵땬땴 땩땮 땡땬땬
땴땩땣땫 땬땡땢땥땬땳 땢땥땩땮땧 땲땯땵땮땤땥땤 땴땯 땴땨땥 땳땡땭땥 땮땵땭땢땥땲딡
las=1
땏땲땩땥땮땴땡땴땩땯땮 땯땦 땡땸땩땳 땬땡땢땥땬땳딮 따 땭땥땡땮땳 땡땬땷땡땹땳 땰땡땲땡땬땬땥땬 땴땯 땡땸땩땳딬 딱 땭땥땡땮땳 땡땬땷땡땹땳 땨땯땲땩땺땯땮땴땡땬딬
땡땮땤 딲 땭땥땡땮땳 땡땬땷땡땹땳 땰땥땲땰땥땮땤땩땣땵땬땡땲 땴땯 땴땨땥 땡땸땩땳딮
mgp=c(3, 1, 0)
땐땯땳땩땴땩땯땮땳 땯땦 땡땸땩땳 땣땯땭땰땯땮땥땮땴땳딮 땔땨땥 딌땲땳땴 땣땯땭땰땯땮땥땮땴 땩땳 땴땨땥 땤땩땳땴땡땮땣땥 땦땲땯땭 땴땨땥 땡땸땩땳 땬땡딭
땢땥땬 땴땯 땴땨땥 땡땸땩땳 땰땯땳땩땴땩땯땮딬 땩땮 땴땥땸땴 땬땩땮땥땳딮 땔땨땥 땳땥땣땯땮땤 땣땯땭땰땯땮땥땮땴 땩땳 땴땨땥 땤땩땳땴땡땮땣땥 땴땯 땴땨땥 땴땩땣땫
땬땡땢땥땬땳딬 땡땮땤 땴땨땥 딌땮땡땬 땣땯땭땰땯땮땥땮땴 땩땳 땴땨땥 땤땩땳땴땡땮땣땥 땦땲땯땭 땴땨땥 땡땸땩땳 땰땯땳땩땴땩땯땮 땴땯 땴땨땥 땡땸땩땳 땬땩땮땥
딨땵땳땵땡땬땬땹 땺땥땲땯딩딮 땐땯땳땩땴땩땶땥 땮땵땭땢땥땲땳 땭땥땡땳땵땲땥 땯땵땴땳땩땤땥 땴땨땥 땰땬땯땴 땲땥땧땩땯땮딬 땮땥땧땡땴땩땶땥 땮땵땭땢땥땲땳 땩땮딭
땳땩땤땥딮
tck=0.01
딱딱딲
때땥땮땧땴땨 땯땦 땴땩땣땫 땭땡땲땫땳딬 땡땳 땡 땦땲땡땣땴땩땯땮 땯땦 땴땨땥 땳땩땺땥 땯땦 땴땨땥 땰땬땯땴땴땩땮땧 땲땥땧땩땯땮딮 땗땨땥땮 땴땣땫 땩땳
땳땭땡땬땬 딨땬땥땳땳 땴땨땡땮 따딮딵딩 땴땨땥 땴땩땣땫 땭땡땲땫땳 땯땮 땴땨땥 땸 땡땮땤 땹 땡땸땥땳 땡땲땥 땦땯땲땣땥땤 땴땯 땢땥 땴땨땥 땳땡땭땥 땳땩땺땥딮
땁 땶땡땬땵땥 땯땦 딱 땧땩땶땥땳 땧땲땩땤 땬땩땮땥땳딮 땎땥땧땡땴땩땶땥 땶땡땬땵땥땳 땧땩땶땥 땴땩땣땫 땭땡땲땫땳 땯땵땴땳땩땤땥 땴땨땥 땰땬땯땴땴땩땮땧 땲땥땧땩땯땮딮
땕땳땥 땴땣땫딽따딮따딱 땡땮땤 땭땧땰딽땣딨딱딬딭딱딮딵딬따딩 땦땯땲 땩땮땴땥땲땮땡땬 땴땩땣땫 땭땡땲땫땳딮
xaxs="r"
yaxs="i"
땁땸땩땳 땳땴땹땬땥땳 땦땯땲 땴땨땥 땸 땡땮땤 땹 땡땸땥땳딬 땲땥땳땰땥땣땴땩땶땥땬땹딮 땗땩땴땨 땳땴땹땬땥땳 딢땩딢 딨땩땮땴땥땲땮땡땬딩 땡땮땤 딢땲딢 딨땴땨땥
땤땥땦땡땵땬땴딩 땴땩땣땫 땭땡땲땫땳 땡땬땷땡땹땳 땦땡땬땬 땷땩땴땨땩땮 땴땨땥 땲땡땮땧땥 땯땦 땴땨땥 땤땡땴땡딬 땨땯땷땥땶땥땲 땳땴땹땬땥 딢땲딢 땬땥땡땶땥땳 땡
땳땭땡땬땬 땡땭땯땵땮땴 땯땦 땳땰땡땣땥 땡땴 땴땨땥 땥땤땧땥땳딮 딨땓 땨땡땳 땯땴땨땥땲 땳땴땹땬땥땳 땮땯땴 땩땭땰땬땥땭땥땮땴땥땤 땩땮 땒딮딩
5.0.9
Figure margins
땁 땳땩땮땧땬땥 땰땬땯땴 땩땮 땒 땩땳 땫땮땯땷땮 땡땳 땡 딌땧땵땲땥 땡땮땤 땣땯땭땰땲땩땳땥땳 땡 땰땬땯땴 땲땥땧땩땯땮 땳땵땲땲땯땵땮땤땥땤 땢땹
땭땡땲땧땩땮땳 딨땰땯땳땳땩땢땬땹 땣땯땮땴땡땩땮땩땮땧 땡땸땩땳 땬땡땢땥땬땳딬 땴땩땴땬땥땳딬 땥땴땣딮딩 땡땮땤 딨땵땳땵땡땬땬땹딩 땢땯땵땮땤땥땤 땢땹 땴땨땥 땡땸땥땳
땴땨땥땭땳땥땬땶땥땳딮
땇땲땡땰땨땩땣땳 땰땡땲땡땭땥땴땥땲땳 땣땯땮땴땲땯땬땬땩땮땧 딌땧땵땲땥 땬땡땹땯땵땴 땩땮땣땬땵땤땥딺
mai=c(1, 0.5, 0.5, 0)
땗땩땤땴땨땳 땯땦 땴땨땥 땢땯땴땴땯땭딬 땬땥땦땴딬 땴땯땰 땡땮땤 땲땩땧땨땴 땭땡땲땧땩땮땳딬 땲땥땳땰땥땣땴땩땶땥땬땹딬 땭땥땡땳땵땲땥땤 땩땮 땩땮땣땨땥땳딮
mar=c(4, 2, 2, 1)
땓땩땭땩땬땡땲 땴땯 땭땡땩딬 땥땸땣땥땰땴 땴땨땥 땭땥땡땳땵땲땥땭땥땮땴 땵땮땩땴 땩땳 땴땥땸땴 땬땩땮땥땳딮 땭땡땲 땡땮땤 땭땡땩 땡땲땥 땥땱땵땩땶땡딭
땬땥땮땴 땩땮 땴땨땥 땳땥땮땳땥 땴땨땡땴 땳땥땴땴땩땮땧 땯땮땥 땣땨땡땮땧땥땳 땴땨땥 땶땡땬땵땥 땯땦 땴땨땥 땯땴땨땥땲딮 땔땨땥 땤땥땦땡땵땬땴 땶땡땬땵땥땳 땣땨땯딭
땳땥땮 땦땯땲 땴땨땩땳 땰땡땲땡땭땥땴땥땲 땡땲땥 땯땦땴땥땮 땴땯땯 땬땡땲땧땥딻 땴땨땥 땲땩땧땨땴딭땨땡땮땤 땭땡땲땧땩땮 땩땳 땲땡땲땥땬땹 땮땥땥땤땥땤딬 땡땮땤
땮땥땩땴땨땥땲 땩땳 땴땨땥 땴땯땰 땭땡땲땧땩땮 땩땦 땮땯 땴땩땴땬땥 땩땳 땢땥땩땮땧 땵땳땥땤딮 땔땨땥 땢땯땴땴땯땭 땡땮땤 땬땥땦땴 땭땡땲땧땩땮땳 땭땵땳땴 땢땥
땬땡땲땧땥 땥땮땯땵땧땨 땴땯 땡땣땣땯땭땭땯땤땡땴땥 땴땨땥 땡땸땩땳 땡땮땤 땴땩땣땫 땬땡땢땥땬땳딮 땆땵땲땴땨땥땲땭땯땲땥딬 땴땨땥 땤땥땦땡땵땬땴 땩땳 땣땨땯딭
땳땥땮 땷땩땴땨땯땵땴 땲땥땧땡땲땤 땴땯 땴땨땥 땳땩땺땥 땯땦 땴땨땥 땤땥땶땩땣땥 땳땵땲땦땡땣땥딺 땦땯땲 땥땸땡땭땰땬땥딬 땵땳땩땮땧 땴땨땥 땰땯땳땴땳땣땲땩땰땴딨딩
땤땲땩땶땥땲 땷땩땴땨 땴땨땥 땨땥땩땧땨땴딽딴 땡땲땧땵땭땥땮땴 땷땩땬땬 땲땥땳땵땬땴 땩땮 땡 땰땬땯땴 땷땨땩땣땨 땩땳 땡땢땯땵땴 딵따 땭땡땲땧땩땮 땵땮땬땥땳땳
땭땡땲 땯땲 땭땡땩 땡땲땥 땳땥땴 땥땸땰땬땩땣땩땴땬땹딮 땗땨땥땮 땭땵땬땴땩땰땬땥 딌땧땵땲땥땳 땡땲땥 땩땮 땵땳땥 딨땳땥땥 땢땥땬땯땷딩 땴땨땥 땭땡땲땧땩땮땳
땡땲땥 땲땥땤땵땣땥땤딬 땨땯땷땥땶땥땲 땴땨땩땳 땭땡땹 땮땯땴 땢땥 땥땮땯땵땧땨 땷땨땥땮 땭땡땮땹 딌땧땵땲땥땳 땳땨땡땲땥 땴땨땥 땳땡땭땥 땰땡땧땥딮
5.0.10
Multiple figure environment
땒 땡땬땬땯땷땳 땹땯땵 땴땯 땣땲땥땡땴땥 땡땮 땮 땢땹 땭 땡땲땲땡땹 땯땦 딌땧땵땲땥땳 땯땮 땡 땳땩땮땧땬땥 땰땡땧땥딮 땅땡땣땨 딌땧땵땲땥 땨땡땳 땩땴땳
땯땷땮 땭땡땲땧땩땮땳딬 땡땮땤 땴땨땥 땡땲땲땡땹 땯땦 딌땧땵땲땥땳 땩땳 땯땰땴땩땯땮땡땬땬땹 땳땵땲땲땯땵땮땤땥땤 땢땹 땡땮 땯땵땴땥땲 땭땡땲땧땩땮딬 땡땳
땳땨땯땷땮 땩땮 땴땨땥 땦땯땬땬땯땷땩땮땧 딌땧땵땲땥딮
땔땨땥 땧땲땡땰땨땩땣땡땬 땰땡땲땡땭땥땴땥땲땳 땲땥땬땡땴땩땮땧 땴땯 땭땵땬땴땩땰땬땥 딌땧땵땲땥땳 땡땲땥 땡땳 땦땯땬땬땯땷땳딺
딱딱딳
mfcol=c(3, 2)
mfrow=c(2, 4)
땓땥땴 땴땨땥 땳땩땺땥 땯땦 땡 땭땵땬땴땩땰땬땥 딌땧땵땲땥 땡땲땲땡땹딮 땔땨땥 딌땲땳땴 땶땡땬땵땥 땩땳 땴땨땥 땮땵땭땢땥땲 땯땦 땲땯땷땳딻 땴땨땥
땳땥땣땯땮땤 땩땳 땴땨땥 땮땵땭땢땥땲 땯땦 땣땯땬땵땭땮땳딮 땔땨땥 땯땮땬땹 땤땩딋땥땲땥땮땣땥 땢땥땴땷땥땥땮 땴땨땥땳땥 땴땷땯 땰땡땲땡땭땥땴땥땲땳 땩땳
땴땨땡땴 땳땥땴땴땩땮땧 땭땦땣땯땬 땣땡땵땳땥땳 딌땧땵땲땥땳 땴땯 땢땥 딌땬땬땥땤 땢땹 땣땯땬땵땭땮딻 땭땦땲땯땷 딌땬땬땳 땢땹 땲땯땷땳딮 땔땨땥 땬땡땹땯땵땴
땩땮 땴땨땥 땆땩땧땵땲땥 땣땯땵땬땤 땨땡땶땥 땢땥땥땮 땣땲땥땡땴땥땤 땢땹 땳땥땴땴땩땮땧 땭땦땲땯땷딽땣딨딳딬딲딩딻 땴땨땥 딌땧땵땲땥 땳땨땯땷땳 땴땨땥 땰땡땧땥
땡땦땴땥땲 땦땯땵땲 땰땬땯땴땳 땨땡땶땥 땢땥땥땮 땤땲땡땷땮딮
땓땥땴땴땩땮땧 땥땩땴땨땥땲 땯땦 땴땨땥땳땥 땣땡땮 땲땥땤땵땣땥 땴땨땥 땢땡땳땥 땳땩땺땥 땯땦 땳땹땭땢땯땬땳 땡땮땤 땴땥땸땴 딨땣땯땮땴땲땯땬땬땥땤 땢땹
땰땡땲딨딢땣땥땸딢딩 땡땮땤 땴땨땥 땰땯땩땮땴땳땩땺땥 땯땦 땴땨땥 땤땥땶땩땣땥딩딮 땉땮 땡 땬땡땹땯땵땴 땷땩땴땨 땥땸땡땣땴땬땹 땴땷땯 땲땯땷땳 땡땮땤
땣땯땬땵땭땮땳 땴땨땥 땢땡땳땥 땳땩땺땥 땩땳 땲땥땤땵땣땥땤 땢땹 땡 땦땡땣땴땯땲 땯땦 따딮딸딳딺 땩땦 땴땨땥땲땥 땡땲땥 땴땨땲땥땥 땯땲 땭땯땲땥 땯땦 땥땩땴땨땥땲
땲땯땷땳 땯땲 땣땯땬땵땭땮땳딬 땴땨땥 땲땥땤땵땣땴땩땯땮 땦땡땣땴땯땲 땩땳 따딮딶딶딮
mfg=c(2, 2, 3, 2)
땐땯땳땩땴땩땯땮 땯땦 땴땨땥 땣땵땲땲땥땮땴 딌땧땵땲땥 땩땮 땡 땭땵땬땴땩땰땬땥 딌땧땵땲땥 땥땮땶땩땲땯땮땭땥땮땴딮 땔땨땥 딌땲땳땴 땴땷땯 땮땵땭땢땥땲땳
땡땲땥 땴땨땥 땲땯땷 땡땮땤 땣땯땬땵땭땮 땯땦 땴땨땥 땣땵땲땲땥땮땴 딌땧땵땲땥딻 땴땨땥 땬땡땳땴 땴땷땯 땡땲땥 땴땨땥 땮땵땭땢땥땲 땯땦 땲땯땷땳 땡땮땤
땣땯땬땵땭땮땳 땩땮 땴땨땥 땭땵땬땴땩땰땬땥 딌땧땵땲땥 땡땲땲땡땹딮 땓땥땴 땴땨땩땳 땰땡땲땡땭땥땴땥땲 땴땯 땪땵땭땰 땢땥땴땷땥땥땮 딌땧땵땲땥땳 땩땮 땴땨땥
땡땲땲땡땹딮 땙땯땵 땣땡땮 땥땶땥땮 땵땳땥 땤땩딋땥땲땥땮땴 땶땡땬땵땥땳 땦땯땲 땴땨땥 땬땡땳땴 땴땷땯 땮땵땭땢땥땲땳 땴땨땡땮 땴땨땥 땴땲땵땥 땶땡땬땵땥땳
땦땯땲 땵땮땥땱땵땡땬땬땹딭땳땩땺땥땤 딌땧땵땲땥땳 땯땮 땴땨땥 땳땡땭땥 땰땡땧땥딮
fig=c(4, 9, 1, 4)/10
땐땯땳땩땴땩땯땮 땯땦 땴땨땥 땣땵땲땲땥땮땴 딌땧땵땲땥 땯땮 땴땨땥 땰땡땧땥딮 땖땡땬땵땥땳 땡땲땥 땴땨땥 땰땯땳땩땴땩땯땮땳 땯땦 땴땨땥 땬땥땦땴딬 땲땩땧땨땴딬
땢땯땴땴땯땭 땡땮땤 땴땯땰 땥땤땧땥땳 땲땥땳땰땥땣땴땩땶땥땬땹딬 땡땳 땡 땰땥땲땣땥땮땴땡땧땥 땯땦 땴땨땥 땰땡땧땥 땭땥땡땳땵땲땥땤 땦땲땯땭 땴땨땥 땢땯땴딭
땴땯땭 땬땥땦땴 땣땯땲땮땥땲딮 땔땨땥 땥땸땡땭땰땬땥 땶땡땬땵땥 땷땯땵땬땤 땢땥 땦땯땲 땡 딌땧땵땲땥 땩땮 땴땨땥 땢땯땴땴땯땭 땲땩땧땨땴 땯땦 땴땨땥
땰땡땧땥딮 땓땥땴 땴땨땩땳 땰땡땲땡땭땥땴땥땲 땦땯땲 땡땲땢땩땴땲땡땲땹 땰땯땳땩땴땩땯땮땩땮땧 땯땦 딌땧땵땲땥땳 땷땩땴땨땩땮 땡 땰땡땧땥딮 땉땦 땹땯땵 땷땡땮땴
땴땯 땡땤땤 땡 딌땧땵땲땥 땴땯 땡 땣땵땲땲땥땮땴 땰땡땧땥딬 땵땳땥 땮땥땷딽땔땒땕땅 땡땳 땷땥땬땬 딨땵땮땬땩땫땥 땓딩딮
oma=c(2, 0, 3, 0)
omi=c(0, 0, 0.8, 0)
땓땩땺땥 땯땦 땯땵땴땥땲 땭땡땲땧땩땮땳딮 때땩땫땥 땭땡땲 땡땮땤 땭땡땩딬 땴땨땥 딌땲땳땴 땭땥땡땳땵땲땥땳 땩땮 땴땥땸땴 땬땩땮땥땳 땡땮땤 땴땨땥
땳땥땣땯땮땤 땩땮 땩땮땣땨땥땳딬 땳땴땡땲땴땩땮땧 땷땩땴땨 땴땨땥 땢땯땴땴땯땭 땭땡땲땧땩땮 땡땮땤 땷땯땲땫땩땮땧 땣땬땯땣땫땷땩땳땥딮 땏땵땴땥땲 땭땡땲땧땩땮땳
땡땲땥 땰땡땲땴땩땣땵땬땡땲땬땹 땵땳땥땦땵땬 땦땯땲 땰땡땧땥딭땷땩땳땥 땴땩땴땬땥땳딬 땥땴땣딮 땔땥땸땴 땣땡땮 땢땥 땡땤땤땥땤 땴땯 땴땨땥 땯땵땴땥땲 땭땡땲땧땩땮땳
땷땩땴땨 땴땨땥 땭땴땥땸땴딨딩 땦땵땮땣땴땩땯땮 땷땩땴땨 땡땲땧땵땭땥땮땴 땯땵땴땥땲딽땔땒땕땅딮 땔땨땥땲땥 땡땲땥 땮땯 땯땵땴땥땲 땭땡땲땧땩땮땳 땢땹
땤땥땦땡땵땬땴딬 땨땯땷땥땶땥땲딬 땳땯 땹땯땵 땭땵땳땴 땣땲땥땡땴땥 땴땨땥땭 땥땸땰땬땩땣땩땴땬땹 땵땳땩땮땧 땯땭땡 땯땲 땯땭땩딮
땍땯땲땥 땣땯땭땰땬땩땣땡땴땥땤 땡땲땲땡땮땧땥땭땥땮땴땳 땯땦 땭땵땬땴땩땰땬땥 딌땧땵땲땥땳 땣땡땮 땢땥 땰땲땯땤땵땣땥땤 땢땹 땴땨땥 땳땰땬땩땴딮땳땣땲땥땥땮딨딩
땡땮땤 땬땡땹땯땵땴딨딩 땦땵땮땣땴땩땯땮땳딬 땡땳 땷땥땬땬 땡땳 땢땹 땴땨땥 땧땲땩땤 땡땮땤 땬땡땴땴땩땣땥 땰땡땣땫땡땧땥땳딮
딱딱딴
제6절
Device drivers
땒 땣땡땮 땧땥땮땥땲땡땴땥 땧땲땡땰땨땩땣땳 딨땯땦 땶땡땲땹땩땮땧 땬땥땶땥땬땳 땯땦 땱땵땡땬땩땴땹딩 땯땮 땡땬땭땯땳땴 땡땮땹 땴땹땰땥 땯땦 땤땩땳땰땬땡땹 땯땲
땰땲땩땮땴땩땮땧 땤땥땶땩땣땥딮 땂땥땦땯땲땥 땴땨땩땳 땣땡땮 땢땥땧땩땮딬 땨땯땷땥땶땥땲딬 땒 땮땥땥땤땳 땴땯 땢땥 땩땮땦땯땲땭땥땤 땷땨땡땴 땴땹땰땥 땯땦
땤땥땶땩땣땥 땩땴 땩땳 땤땥땡땬땩땮땧 땷땩땴땨딮 땔땨땩땳 땩땳 땤땯땮땥 땢땹 땳땴땡땲땴땩땮땧 땡 땤땥땶땩땣땥 땤땲땩땶땥땲딮 땔땨땥 땰땵땲땰땯땳땥 땯땦 땡
땤땥땶땩땣땥 땤땲땩땶땥땲 땩땳 땴땯 땣땯땮땶땥땲땴 땧땲땡땰땨땩땣땡땬 땩땮땳땴땲땵땣땴땩땯땮땳 땦땲땯땭 땒 딨땜땤땲땡땷 땡 땬땩땮땥딬딢 땦땯땲 땥땸땡땭땰땬땥딩
땩땮땴땯 땡 땦땯땲땭 땴땨땡땴 땴땨땥 땰땡땲땴땩땣땵땬땡땲 땤땥땶땩땣땥 땣땡땮 땵땮땤땥땲땳땴땡땮땤딮
땄땥땶땩땣땥 땤땲땩땶땥땲땳 땡땲땥 땳땴땡땲땴땥땤 땢땹 땣땡땬땬땩땮땧 땡 땤땥땶땩땣땥 땤땲땩땶땥땲 땦땵땮땣땴땩땯땮딮 땔땨땥땲땥 땩땳 땯땮땥 땳땵땣땨 땦땵땮땣딭
땴땩땯땮 땦땯땲 땥땶땥땲땹 땤땥땶땩땣땥 땤땲땩땶땥땲딺 땴땹땰땥 help(Devices) 땦땯땲 땡 땬땩땳땴 땯땦 땴땨땥땭 땡땬땬딮 땆땯땲 땥땸땡땭땰땬땥딬 땩땳딭
땳땵땩땮땧 땴땨땥 땣땯땭땭땡땮땤
postscript()
X11()
windows()
quartz()
pdf()
png()
jpeg()
:
:
:
:
:
:
:
sent graphics output to the printer in PostScript format
For use with the X11 window system on Unix-alikes
For use on Windows
For use on MacOS X
Produces a PDF file, which can also be included into PDF files.
Produces a bitmap PNG file.
Produces a bitmap JPEG file, best used for image plots.
• 땰땯땳땴땳땣땲땩땰땴
> postscript("file.ps", horizontal=FALSE, height=5, pointsize=10)
> hist(rnorm(10000))
> dev.off()
제7절
Dynamic graphics
땒 땤땯땥땳 땮땯땴 땨땡땶땥 땢땵땩땬땴땩땮 땣땡땰땡땢땩땬땩땴땩땥땳 땦땯땲 땤땹땮땡땭땩땣 땯땲 땩땮땴땥땲땡땣땴땩땶땥 땧땲땡땰땨땩땣땳딬 땥딮땧딮 땲땯땴땡땴땩땮땧
땰땯땩땮땴 땣땬땯땵땤땳 땯땲 땴땯 땜땢땲땵땳땨땩땮땧딢 딨땩땮땴땥땲땡땣땴땩땶땥땬땹 땨땩땧땨땬땩땧땨땴땩땮땧딩 땰땯땩땮땴땳딮 땈땯땷땥땶땥땲딬 땥땸땴땥땮땳땩땶땥 땤땹딭
땮땡땭땩땣 땧땲땡땰땨땩땣땳 땦땡땣땩땬땩땴땩땥땳 땡땲땥 땡땶땡땩땬땡땢땬땥 땩땮 땴땨땥 땳땹땳땴땥땭 땇땇땯땢땩 땢땹 땓땷땡땹땮땥딬 땃땯땯땫 땡땮땤 땂땵땪땡
땡땶땡땩땬땡땢땬땥 땦땲땯땭
http://www.ggobi.org/ 땡땮땤 땴땨땥땳땥 땣땡땮 땢땥 땡땣땣땥땳땳땥땤 땦땲땯땭 땒 땶땩땡 땴땨땥 땰땡땣땫땡땧땥 땲땧땧땯땢땩딬
땤땥땳땣땲땩땢땥땤 땡땴 http://www.ggobi.org/rggobi딮
땁땬땳땯딬 땰땡땣땫땡땧땥 땲땧땬 땰땲땯땶땩땤땥땳 땷땡땹땳 땴땯 땩땮땴땥땲땡땣땴 땷땩땴땨 딳땄 땰땬땯땴땳딬 땦땯땲 땥땸땡땭땰땬땥 땯땦 땳땵땲땦땡땣땥땳딮
딱딱딵
딱딱딶
제 III 편
C 와 R 을 이용한 기초통계의 계산
딱딱딷
제 18 장
확률과 확률분포
확률 (probability) 은 모집단 (population) 에서 표본 (sample) 을 추출할 때딬 어떤 특정한 성질
을 만족하는 표본이 관측될 가능성에 대한 측도로 표본을 바탕으로 모집단에 대한 결론을
이끌어내는 데 논리적 근거가 된다딮
• 표본공간 (sample space) S 통계적 조사 혹은 실험에서 얻을 수 있는 모든 가능한 결
과들의 전체집합
• 사건 (event) A 표본공간의 부분집합
제1절
확률 (probability) 의 고전적 정의
라플라스 (Laplace) 딻 딱딷딴딹딭딱딸딲딷
• 따 < n딨S딩 < ∞ 이고 각각의 근원사건이 일어날 가능성이 같을 때딬 임의의 사건 A 의
확률은
P 딨A딩 딽 n딨A딩/n딨S딩
로 정의된다딮
• 성질
– 따 ≤ P 딨A딩 ≤ 딱딬
– P 딨S딩 딽 딱
– A ∩ B 딽 ∅ 이면 P 딨A ∪ B딩 딽 P 딨A딩 딫 P 딨B딩딮
• 문제점 딺 각 근원사건이 일어날 가능성이 동일하지 않으면 딿
딱딱딹
제2절
공리적 정의 ( 콜모고로프 (Kolmogorov) ; 1903-1987
P 딺 {A 딺 A ⊂ S} → 땛따, 딱땝 땳땵땣땨 땴땨땡땴
딱딮 따 ≤ P 딨A딩 ≤ 딱딬
딲딮 P 딨S딩 딽 딱
딳딮 서로 배반인 사건열 {Ai } 에 대하여 P 딨∪∞
i=1 Ai 딩 딽
제3절
P∞
i=1
P 딨Ai 딩딮
확률에 관한 성질
딱딮 공사건의 확률 P 딨∅딩 딽 따
딲딮 덧셈법칙 P 딨A ∪ B딩 딽 P 딨A딩 딫 P 딨B딩 − P 딨A ∩ B딩
딳딮 여사건의 확률 P 딨Ac 딩 딽 딱 − P 딨A딩
딴딮 땉땦 A ⊂ B 땴땨땥땮 P 딨A딩 ≤ P 딨B딩
제4절
확률변수 및 확률분포
확률변수 (random variable)딺 표본공간 S 에서 정의된 실함수딬 X 딺 S → R딮
확률분포 (probability distribution)딺 표본공간에서 정의된 확률 P 를 확률변수 X 의 값에
따라 재표현하여 나타낸 것을 X 의 확률분포라고 한다딮 즉딬
땆땯땲 땡땬땬 A ⊂ S, X딨A딩 딽 {X딨ω딩 딺 ω ∈ A} ≡ B,
땴땨땥땮 P 딨A딩 딽 땐땲딨B딩 딽 P 딨X −1 딨A딩딩 딽 P 딨X ∈ B딩.
딽⇒ 확률을 점함수 딨땰땯땩땮땴 땦땵땮땣땴땩땯땮딩 로 표현할 수 없을까 딿
X 의 누적분포함수 (cumulative distribution function; c.d.f.)딺
F 딺 R → 땛따, 딱땝, 땴땨땡땴 땩땳딬
F 딨x딩 딽 P 딨X ∈ 딨−∞, x땝딩 ≡ P 딨X ≤ x딩.
딱딲따
제5절
확률질량함수
확률질량함수 (probability mass function; p.m.f.) 딺 확률 분포함수가 딨−∞, x땝 에서의 확률을
나타내는 반면 한점에서의 확률를 표현한 함수딮
p딨x딩 딽 P 딨X 딽 x딩
•
Px
y=−∞
p딨y딩 딽 F 딨x딩
• p딨x딩 ≥ 따
• P 딨a ≤ X ≤ b딩 딽
제6절
Pb
a
p딨y딩
확률밀도함수
확률밀도함수 (probability density function; p.d.f.) 딺 확률 분포함수를 미분한 함수딮 때때로
확률질량함수가 모든점에서 따 이 되는 수가 있음딮
f 딨x딩 딽
•
Rx
0
dF 딨x딩
dx
f 딨y딩dy 딽 F 딨x딩
• f 딨x딩 ≥ 따
• P 딨a ≤ X ≤ b딩 딽
제7절
Rb
a
f 딨y딩dy
기대값 (expectation)
위에서 정의한 분포함수를 이용하여 확률을 수학적으로 표현할 수 있다는 것은 우리가 그
러한 확률메카니즘의 지배를 받는 모든 현상에 대하여 알고 있다는 것을 의미함딮
즉딬 인간이 현상을 이해하기 위하여 할수있는 최대한은 그 현상을 만들어 내는 확률을 아는
것까지이다딮
하지만 우리앞에 놓여진 현상은 우리에게 수학적 확률구조를 알려주지는 않는다딮
다만 우리는 자료를 얻을 뿐이다딮
얻어진 자료를 이용하여 현상에 대한 확률 구조를 나타내야 한다딮
많은 수학자 딯 통계학자들의 노력에 의하여딬 다음의 모든 기대값을 알면 확률을 표현할
수 있다는 사실이 밝혀졌다딮
E딨X딩, E딨X 2 딩, . . . , E딨X ∞ 딩.
딱딲딱
E딨X r 딩 을 X 의 r 차 적률 (moment) 라고 하고 정의는 아래와 같다딮
Z
X
r
E딨X 딩 딽 xr f 딨x딩dx, 땯땲 E딨X r 딩 딽
xr p딨x딩.
∀x
주어진 딨관측된딩 자료를 이용하여 위의 기대값을 계산할 수 있나 딿
n
딱X r
E딨X 딩 '
x.
n i=1 i
r
r 딽 딱 인 경우 위의 오른쪽 식은 아래와 같으며딬 표본평균이라고 한다딮
n
X
딖딽 딱
Xi .
X
n i=1
r 딽 딲 인 경우딬 표본분산이라고 한다딮
n
딱 X
딖 2딽 n
S 딽
딨Xi − X딩
n − 딱 i=1
n−딱
2
딱딲딲
(
n
딱X 2
X
n i=1 i
)
−
n 딖2
X .
n−딱
제 19 장
여러 가지 분포
유한한 관측자료를 가지고 모든 확률분포를 재구성하기는 불가능하다딮 따라서 현상의 확률
구조를 표현할 수 있는 이론적인 확률분포를 고려한다면 적은 추정치를 이용하여 현상의
확률 구조를 설명할 수 있다딮
제1절
균등분포 (uniform distribution)
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void runif(int n, double *r);
int main()
{
double r[10];
int i;
runif(10, r);
for(i=0; i<10; i++) printf("random[%d]=%f\n", i, r[i]);
return 0;
}
void runif(int n, double *r)
{
int i;
unsigned seed = (unsigned)time(NULL);
srand(seed);
for(i =0; i<100; i++) rand()/(RAND_MAX+1.0);
for(i =0; i<n; i++) r[i] = rand()/(RAND_MAX+1.0);
딱딲딳
}
제2절
베르누이분포
베르누이실험딺 결과가 오직 두 가지 딨성공 딨땳딩 또는 실패 딨땦딩딩 뿐인 실험
표본공간 딺 S 딽 {s, f }딬 P 딨s딩 딽 p 라 할때딬 확률변수 X 를 X딨s딩 딽 딱, X딨f 딩 딽 따 와 같이
정의하면딬 X 의 확률질량함수는
p딨x딩 딽 px 딨딱 − p딩1−x , x 딽 따, 딱.
이러한 분포에서는 p 를 알면 모든것을 아는 것이다딮 어떻게 하면 p 를 알 수 있을까 딿
동일한 조건에서의 딱따 번의 실험결과가 다음과 같다고 하자딮
f sf f f f f ssf
p땞 딽 딳/딱따딨why딿딩
void rbern(double p, int n, double *r)
{
int i;
runif(n, r);// see 균등분포
for(i = 0; i<n; i++){
if(r()< p) r[i] = 1;
else
r[i] = 0;
}
}
제3절
이항분포 (binomial distribution)
위의 개개의 실험결과를 확률변수 딨X1 , . . . , X10 딩 를 이용해서 나타내면딬 p 의 추정치는
10
딱 X
p땞 딽
Xi .
딱따 i=1
여기서딬
P10
i=1
Xi 의 확률분포는
딱따 x
p딨x딩 딽
p 딨딱 − p딩10−x , x 딽 따, 딱, . . . , 딱따,
x
딱딲딴
이며 이를 이항분포라고 한다딮 이항분포의 기대값은 np 딽 딱따 × p 이다딮
따라서
!
10
X
딱
E딨땞
p딩 딽 E
Xi 딽 p.
딱따
i=1
위의 개개의 실험결과를 확률변수 딨X1 , . . . , X10 딩 를 이용해서 나타내면딬 p 의 추정치는
10
딱 X
p땞 딽
Xi .
딱따 i=1
여기서딬
P10
i=1
Xi 의 확률분포는
딱따 x
p딨x딩 딽
p 딨딱 − p딩10−x , x 딽 따, 딱, . . . , 딱따,
x
이며 이를 이항분포라고 한다딮 이항분포의 기대값은 np 딽 딱따 × p 이다딮
따라서
!
10
X
딱
E딨땞
p딩 딽 E
Xi 딽 p.
딱따
i=1
double factorial(double x)
{
if(x <= 1) return(1);
else return(x*factorial(x-1));
}
double choose(double n, double x)
{
double v;
if(n <= 0 || x <= 0) return(0);
v = n/x;
while(1){
n--; x--;
if(n < 1 || x < 1) break;
v *= (n/x);
}
return(v);
}
double dbinom(int n, double p, double x)
{
double v;
딱딲딵
v = choose(n, x)*pow(p, x)*pow((1-p), (double)n-x);
return(v);
}
제4절
정규분포 (normal distribution)
확률밀도함수가 아래와 같이 주어진 분포를 정규분포라고 한다딮
딱
딨x − µ딩2
.
f 딨x딩 딽 √
땥땸땰 −
딲σ 2
딲πσ 2
확률변수 X 가 정규분포를 따를 때 이를 X ∼ N 딨µ, σ 2 딩 로 표현한다딮
#define PI 3.141592
double dnorm(double mu, double sigma)
{
return(1.0/sqrt(2.0*PI)*sigma*exp(-(x-mu)*(x-mu)/(2*sigma*sigma)));
}
정규분포에서의 확률계산 : 오차 함수 딨誤差函數딬 땥땲땲땯땲 땦땵땮땣땴땩땯땮딩 는 확률론딬 통계학딬 편미분
방정식등에서 사용하는 땮땯땮딭땥땬땥땭땥땮땴땡땲땹 땦땵땮땣땴땩땯땮 이다딮 가우스 오차 함수라고도 하며 다음
과 같이 정의된다딮
Z x
딲
2
erf 딨x딩 딽 √
e−t dt.
π 0
이를 이용하여 정규분포의 땣땤땦 를 아래와 같이 표현할 수 있다딮
딱
x
P 딨X ≤ x딩 딽 딈딨x딩 딽
.
딱 딫 땥땲땦 √
딲
딲
오차함수는 땔땡땹땬땯땲 땳땥땲땩땥땳 로 표현하면
∞
딲 X 딨−딱딩n x2n+1
딲
x3 x5 x7
x9
erf 딨x딩 딽 √
딽√
x−
딫
−
딫
− ···
딳
딱따 딴딲 딲딱딶
π n=0 n딡딨딲n 딫 딱딩
π
이고딬 아래와 같이 근사식을 이용하여 계산한다딮
2
2
2 딴/π 딫 ax
,
딨erf 딨x딩딩 ≈ 딱 − 땥땸땰 −x
딱 딫 ax2
여기서
a딽
−딸 π − 딳
.
딳π π − 딴
딱딲딶
땇땎땕 땃딯땃딫딫 에서는 <땭땡땴땨딮땨 > 에 오차함수의 계산을 위한 땥땲땦딨딩함수를 정의하여 사용하고
있다딮
#include <stdio.h>
#include <math.h>
double pnorm(double x)
{
return ( 0.5 * (1+erf(x/sqrt(2))) );
}
int main()
{
int i;
double x;
for(i=0; i<=9; i++){
x = (double)i/2 - 3;
printf("P(X<%f) = %f\n", x, pnorm(x));
}
return 0;
}
Box-Muller (1958) transformation:
균등분포에서 서로 독립인 난수를 U1 , U2 라고 할 때딬 다음과 같은 변환을 Box-Muller 변환
이라고 한다딮
p
−딲 땬땮딨U1 딩 땣땯땳딨딲πU2 딩
p
X2 딽 −딲 땬땮딨U1 딩 땳땩땮딨딲πU2 딩
X1 딽
또한 위의 변환에 의해 생성되는 X1 , X2 는 서로 독립인 표준정규분포를 따른다딮
#define PI 3.141592
void rnorm(int n, double *r)
{
double *U1, *U2;
runif(n, U1);
runif(n, U2);
for(i=0; i<n; i++){
r[i] = sqrt( - 2 * log(U1[i]) ) * cos( 2*PI*U2[i] )
//r[i] = sqrt( - 2 * log(U1[i]) ) * sin( 2*PI*U2[i] )
딱딲딷
}
}
Remark:땂땯땸딭땍땵땬땬땥땲 변환을 땰땯땬땡땲 땦땯땲땭 으로 바꾸면 더 땲땯땢땵땳땴 한 난수를 발생시킬 수 있다딮
제5절
지수분포 (exponential distribution)
확률밀도함수가 아래와 같이 주어진 분포를 지수분포라고 하고 확률변수 X 가 지수분포를
따를 때 X ∼ E딨λ딩 로 표현한다딮
f 딨x딩 딽 λe−λx I딨x ≥ 따딩.
지수분포의 누적분포함수 딨땣땤땦딩 는 아래와 같다딮
x
Z
F 딨x딩 딽
λe−λy dy 딽 딱 − e−λx .
f 딨y딩dy 딽
0
제6절
x
Z
0
감마분포 (gamma distribution)
X 땩땳 땡 땧땡땭땭땡 땲딮땶 땡땮땤 땤땥땮땯땴땥 땩땴 땡땳 X ∼ Gamma딨α, 딱/β딩 땩땦 땰땤땦 땯땦 X 땩땳
f 딨x딩 딽
딱
xα−1 땥땸땰 딨−x/β딩I딨x ≥ 따딩,
딀딨α딩β α
땯땲
f 딨x딩 딽
λα α−1
x
땥땸땰 딨−λx딩I딨x ≥ 따딩,
딀딨α딩
땷땨땥땲땥 딀딨·딩딬 땣땡땬땬땥땤 땴땨땥 땧땡땭땭땡 땦땵땮땣땴땩땯땮 땤땥딌땮땥땤 땢땹
Z
∞
xα−1 e−x dx.
딀딨α딩 딽
0
• 땔땨땥 땰땲땯땰땥땲땴땹 땯땦 땴땨땥 땧땡땭땭땡 땦땵땮땣땴땩땯땮 딺
딀딨α딩 딽 딨α − 딱딩딀딨α − 딱딩
• 땉땦 α 딽 n 땩땳 땩땮땴땥땧땥땲
딀딨딱딩 딽 딱, 딀딨n딩 딽 딨n − 딱딩딡.
• Tn 땩땳 땴땨땥 땡땭땯땵땮땴 땯땦 땷땡땩땴땩땮땧 땴땩땭땥 땵땮땴땩땬 n 땥땶땥땮땴땳 땨땡땳 땯땣땣땵땲땲땥땤딮 때땥땴 N 딨t딩 땢땥 땡 땮땵땭땢땥땲
딱딲딸
땯땦 땥땶땥땮땴땳 땯땣땣땵땲땲땥땤 땩땮 땴땩땭땥 땛따, t땝 땡땮땤 땡땳땳땵땭땥 N 딨t딩 ∼ P oisson딨λt딩딬
P 딨Tn ≤ t딩 딽 P 딨N 딨t딩 ≥ n딩 딽
∞
X
P 딨N 딨t딩 딽 j딩 딽
j=n
∞
X
e−λt 딨λt딩j
j=n
j딡
d
P 딨Tn ≤ t딩
dt
∞
X
e−λt j딨λt딩j−1 λ − λe−λt 딨λt딩j
딽
j딡
j=n
fTn 딨t딩 딽
딽
∞
X
λe−λt 딨λt딩j−1
딨j − 딱딩딡
j=n
딽
−
∞
X
λe−λt 딨λt딩j
j=n
j딡
λe−λt 딨λt딩n−1
딨n − 딱딩딡
땈땥땮땣땥딬 f 땩땳 땴땨땥 땧땡땭땭땡 땤땥땮땳땩땴땹딮
Z
딀딨z딩 딽
∞
딨tz−1 땥땸땰딨−t딩딩dt
0
때땡땮땣땺땯땳 땡땰땰땲땯땸땩땭땡땴땩땯땮딺
딀딨z딩 딽
√
딲π/z
p0 딫
6
X
!!
pn /딨z 딫 n딩
딨z 딫 딵.딵딩z+0.5 땥땸땰딨−z − 딵.딵딩,
n=1
땷땨땥땲땥
p0 딽 딱.따따따따따따따따따딱딹따따딱딵, p1 딽 딷딶.딱딸따따딹딱딷딲딹딴딷딱딴딶, p2 딽 −딸딶.딵따딵딳딲따딳딲딹딴딱딶딷딷, p3 딽 딲딴.따딱딴따딹딸딲딴따딸딳따딹딱,
p4 딽 −딱.딲딳딱딷딳딹딵딷딲딴딵따딱딵딵, p5 딽 딱.딲따딸딶딵따딹딷딳딸딶딶딱딷딹 × 딱따−3 , p6 딽 −딵.딳딹딵딲딳딹딳딸딴딹딵딳 × 딱따−6
딮
땓땴땩땲땬땩땮땧딧땳 땦땯땲땭땵땬땡딺
땬땮 딀딨z딩 ≈ z 땬땮딨z딩 − z 딫 땬땮
p
딲π/z 딫 z 9 /딱딱딸딸 − z 7 /딱딶딸따 딫 z 5 /딱딲딶따 − z 3 /딳딶따 딫 z/딱딲.
float gammln(float xx) // logarithm of gamma function
{
double x,y,tmp,ser;
static double cof[6]={76.18009172947146,-86.50532032941677,
24.01409824083091,-1.231739572450155,
딱딲딹
0.1208650973866179e-2,-0.5395239384953e-5};
int j;
y=x=xx;
tmp=x+5.5;
tmp -= (x+0.5)*log(tmp);
ser=1.000000000190015;
for (j=0;j<=5;j++) ser += cof[j]/++y;
return (-tmp+log(2.5066282746310005*ser/x));
}
땉땮땣땯땭땰땬땥땴땥 땧땡땭땭땡 땦땵땮땣땴땩땯땮
x
Z
ta−1 e−t dt 딽 xa e−x
γ딨a, x딩 딽
0
∞
X
n=0
xn
a딨a 딫 딱딩 · · · 딨a 딫 n딩
int pgamma(double a, double b, double *out)
{
}
제7절
t 분포의 누적확률함수 (cdf )
땴 분포의 땣땤땦딨땣땵땭땭땵땬땡땴땩땶땥 땤땩땳땴땲땩땢땵땴땩땯땮 땦땵땮땣땴땩땯땮딩딺
땐땲딨t딨n딩 ≤ x딩 딽 딱 −
B
n
x2 +n
B
딻
n 1
,
2 2
n 1
,
2 2
땷땨땥땲땥 B딨a, b딩 땩땳 땴땨땥 땢땥땴땡 땦땵땮땣땴땩땯땮딺
1
Z
ta−1 딨딱 − t딩b−1 dt,
B딨a, b딩 딽
0
땡땮땤 B딨x딻 a, b딩 땩땳 땴땨땥 땩땮땣땯땭땰땬땥땴땥 땢땥땴땡 땦땵땮땣땴땩땯땮딺
Z
B딨x딻 a, b딩 딽
x
ta−1 딨딱 − t딩b−1 dt.
0
딱딳따
땉땦 α, β 땡땲땥 땩땮땴땥땧땥땲 땶땡땬땵땥땳 땴땨땥땮딺
a+b−1
X
딨a 딫 b − 딱딩딡
xj 딨딱 − x딩a+b−1−j
j딡딨a
딫
b
−
딱
−
j딩딡
j=a
"
#
∞
X
xa 딨딱 − x딩b
B딨a 딫 딱, n 딫 딱딩 n+1
딽
딱딫
x
.
aB딨a, b딩
B딨a 딫 b, n 딫 딱딩
n=0
B딨x딻 a, b딩
딽
B딨a, b딩
딱딳딱
#include <math.h>
#define MAXIT 100
#define EPS 3.0e-7
#define FPMIN 1.0e-30
int betacf(float a, float b, float x, float *out);
float gammln(float xx);
int betai(float a, float b, float x, float *out);
int betai(float a, float b, float x, float *out)
{
float bt, beta_cdf;
if (x < 0.0 || x > 1.0) return(-1)//Bad x in routine betai
if (x == 0.0 || x == 1.0) bt=0.0;
bt=exp(gammln(a+b)-gammln(a)-gammln(b)+a*log(x)+b*log(1.0-x));
if (x < (a+1.0)/(a+b+2.0)){
if(betacf(a,b,x, &beta_cdf) == -1) return(-1);
*out = bt*beta_cdf/a;
}
else {
if(betacf(b,a,1.0-x, &beta_cdf) == -1) return(-1);
*out = 1.0-bt*beta_cdf/b;
}
return(0);
}
int betacf(float a, float b, float x, double *out)
{
int m,m2;
float aa,c,d,del,h,qab,qam,qap;
qab=a+b; qap=a+1.0; qam=a-1.0;
c=1.0; d=1.0-qab*x/qap;
if (fabs(d) < FPMIN) d=FPMIN;
d=1.0/d; h=d;
딱딳딲
for (m=1;m<=MAXIT;m++) {
m2=2*m;
aa=m*(b-m)*x/((qam+m2)*(a+m2));
d=1.0+aa*d;
if (fabs(d) < FPMIN) d=FPMIN;
c=1.0+aa/c;
if (fabs(c) < FPMIN) c=FPMIN;
d=1.0/d;
h *= d*c;
aa = -(a+m)*(qab+m)*x/((a+m2)*(qap+m2));
d=1.0+aa*d;
if (fabs(d) < FPMIN) d=FPMIN;
c=1.0+aa/c;
if (fabs(c) < FPMIN) c=FPMIN;
d=1.0/d;
del=d*c;
h *= del;
if (fabs(del-1.0) < EPS) break;
}
if (m > MAXIT)
{
printf("a or b too big, or MAXIT too small in betacf\n");
return(-1);
}
*out = h;
return (0);
}
딱딳딳
딱딳딴
제 20 장
기술통계
제1절
Boxplot(상자그림)
• 땲땥땡땤 땤땡땴땡 땡땮땤 땯땲땤땥땲땩땮땧
X(1) , . . . , X(n)
• Q1 , Q2 , Q3 계산 딺
X([n/4]) 딫 X([n/4]+1)
딲
X([n/2]) 딫 X([n/2]+1)
Q2 딽
딲
X([3×n/4]) 딫 X([3×n/4]+1)
Q3 딽
딲
Q1 딽
• IQR(interquartile range; 4 분위수범위) 의 계산 딺
IQR 딽 Q3 − Q1
• 땂땯땸 그리기 딨상자의 위 아래의 좌표계산딩딺
bottom 딽 Q1 − 딱.딵 ∗ IQR,
top 딽 Q3 딫 딱.딵 ∗ IQR
• 땂땯땸 밖 수염 딨땷땨땩땳땫땥땲딩 그리기 딺 상자의 아래 혹은 위로 다음의 값까지를 선으로 연결
함
w1 딽 Q1 − 딱.딵 ∗ IQR, w2 딽 Q3 딫 딱.딵 ∗ IQR
딱딳딵
그림 딲따딮딱딺 상자그림
• 이상치 (outlier) 판정 딺
X < Q1 − 딱.딵 ∗ IQR 또는 X > Q3 딫 딱.딵 ∗ IQR
– 땜땅땸땴땲땥땭땥딢 땯땵땴땬땩땥땲땳딺
X < Q1 − 딳 ∗ IQR 또는 X > Q3 딫 딳 ∗ IQR
– 딢땍땩땬땤딢 땯땵땴땬땩땥땲땳
Q1 − 딳 ∗ IQR < X < Q1 − 딱.딵 ∗ IQR 또는
Q3 딫 딱.딵 ∗ IQR < X < Q3 딫 딳 ∗ IQR
딱딳딶
제 21 장
모집단의 평균검증
청소년의 신장이 딱따 년 전의 기준신장에 비해 커졌는가 딿 새로운 제품이 개발했을 때 기존의
제품에 비해 품질 딨선호도딩 이 좋은지 비교 신약을 투여하기 전후 효과차이가 있는지
제1절
모집단의 모평균 추론
신뢰구간 딺 표본으로부터 모집단의 어떤 모수의 범위를 추측하는 것 어떤구간에 모수가 포
함될 확률이 정해진 경우딬 이러한 구간은 여러 개가 있을 수 있으며딬 신뢰구간은 그러한
구간들 중에 가장 짧은 구간을 의미한다
땇땲땯땵땰
땇땲땯땵땰딨땘딩 딳딸
땇땲땯땵땰딨땙딩 딱딲
관측치
딲딶 딲딶 딳딴 딳딱 딴딵
딴 딱딷 딱딷 딱딸 딳딲
t.test(x, y = NULL, alternative = c("two.sided", "less", "greater"),
mu = 0, paired = FALSE, var.equal = FALSE,
conf.level = 0.95, ...)
t.test(x, y, paired=FALSE)
t.test(x, y, paired=TRUE)
var.test(x, y, ratio = 1,
alternative = c("two.sided", "less", "greater"),
conf.level = 0.95, ...)
var.test(x, y)
딱딳딷
제2절
2.1
t 검정 (t-test)
일표본 t 검정 (one sample t-test)
data: y
t = -0.1083, df = 98, p-value = 0.914
H_1: mean != 0
95 percent confidence interval:
-1.0604571 0.9507325
sample estimates:
mean of x
-0.05486229
표본자료 딺
X1 , . . . , Xn ∼ N 딨µ, σ 2 딩
모집단의 평균이 µ0 딨우리가 예상하는 특정한 값딩 인지를 관측된 표본을 이용하여 검증 이
때의 가설은
H0 딺 µ 딽 µ0 땶딮땳딮 H1 딺 µ 6딽 µ0 .
표본평균딺
n
X
딖딽 딱
Xi ∼ N 딨µ, σ 2 /n딩
X
n i=1
귀무무가설이 참일 때딬 위의 결과를 이용하면딬
딖 − µ0
X
√ ∼ N 딨따, 딱딩 딺 표준정규분포
σ/ n
딨딲딱딮딱딩
만일 모집단의 분산 딨σ 2 딩 을 안다면 위를 이용하여 검증 가능
대부분의 경우딬 모집단의 분산을 모른다딮 따라서 모분산을 추정해야 함딮
표본분산딺
n
딱 X
2
딖 2
s 딽
딨Xi − X딩
n − 딱 i=1
위의 딨딱딩 식에서 모표준편차를 표본표준편차로 대체한 식은 다음과 같이 되고 이를 t 통계량
이라고 부름
딖 − µ0
X
√ ∼ t딨n − 딱딩
t딽
s/ n
위의 땴 통계량은 자유도 (degree of freedom) 가 n − 딱 인 땴땥땲땭땴 분포를 따른다고 한다딮
여기서 귀무가설을 기각하기 위해서는 표본자료를 이용하여 위에서 구한 t 값 딨t0 딩 이 어
딱딳딸
그림 딲딱딮딱딺 정규분포와 땴 분포의 확률밀도함수
떤 값보다 커야한다딮 어떤 값은 우리가 어떤 유의수준을 사용하느냐와 땴 통계량의 자유도에
따라 달라진다딮
통상적으로 유의수준에 따른 어떤 값 (critical value) 를 구하는 것 대신에 구해진 땴 통계
량이 땴 값보다 클 확률을 계산하는 데딬 이를 유의 확률 (p-value) 이라고 하며 다음처럼 구한
다딮
땐땲딨t > t0 딩 딽 딱 − 땐땲딨t ≤ t0 딩
따라서 땰딭땶땡땬땵땥 를 계산하기 위해서는 땴 분포의 확률분포함수를 계산하여야 하며딬 땩땮땣땯땭땰땬땥땴땥
땢땥땴땡 함수를 이용한다딮
t 분포와 정규분포의 비교
2.2
Two Sample t-test(표본수가 같을 때)
표본자료 딺
X1 , . . . , Xn ∼ N 딨µ1 , σ 2 딩
Y1 , . . . , Yn ∼ N 딨µ2 , σ 2 딩
두 모집단의 평균의 차가 있는지를 관측된 표본을 이용하여 검증 이 때의 가설은
H0 딺 µ1 딽 µ2 땶딮땳딮 H1 딺 µ1 6딽 µ2 .
딱딳딹
표본평균 딺
n
n
X
딱X
딖딽 딱
X
Xi ∼ N 딨µ1 , σ 2 /n딩, Y딖 딽
Yi ∼ N 딨µ2 , σ 2 /n딩
n i=1
n i=1
검정통계량 (test statistic)딺
t딽
2.3
q
딖 − Y딖
X
딽
땷땨땥땲땥 sX−
s2X¯ 딫 s2Y¯
¯ Y¯
sX−
¯ Y¯
Two Sample t-test(표본수가 다를 때)
표본자료 딺
X1 , . . . , Xn ∼ N 딨µ1 , σ 2 딩
Y1 , . . . , Ym ∼ N 딨µ2 , σ 2 딩
검정통계량 딺
t딽
땷땨땥땲땥
s
sX−
¯ Y¯ 딽
2.4
딖 − Y딖
X
sX−
¯ Y¯
딨n − 딱딩s2X 딫 딨m − 딱딩s2Y
n딫m−딲
딱
딱
딫
m m
대응비교 (Paired t-test)
표본자료 딺
딨X1 , Y1 딩, . . . , 딨Xn , Yn 딩 ∼ N
! !
µ1
,딆
µ2
땔땨땥땮
D1 딽 X1 − Y1 , . . . , Dn 딽 Xn − Yn ∼ N 딨µ1 − µ2 , σ 2 딩
검정통계량 딺
t딽
딖
D
√
sD / n
단딬
n
s2D 딽
딱 X
딖 2
딨Di − D딩
n − 딱 i=1
딱딴따
제 22 장
카이제곱 검정
자유도딨땄땥땧땲땥땥 땏땦 땆땲땥땥땤땯땭딬 自由度딩 는 설명하고자 하는 계를 완전히 표현하고자 할때
요한 최소한의 변수땻 예를 들어 딳 차원의 어느 특정 좌표을 나태내기 위해서는 딳 개의
수 딨x, y, z딩 가 필요하게 되는데딬 이 변수의 최소한의 개수를 말한다딮 백터에서는 어느
벡터공간을 표현하기 위해 필요한 단위벡터의 개수를 의미하며딬 벡터공간의 모든 점은
개수만큼의 단위벡터로 모두 표현 가능하다딮
제1절
필
변
한
그
독립성검정
다음은 좌석벨트를 맬 경우와 그렇지 않은 경우에 대하여 승객의 상해정도를 조사한 자료
이다딮
벨트착용유무
딨X딩
땙땥땳
땎땯
상해정도 딨Y 딩
없음
경상
중상
딱딲딬딸딱딳
딶딴딷
딳딵딹
딶딵딬딹딶딳
딴딬따따따
딲딬딶딴딲
사망
딴딲
딳따딳
위의 자료에서 좌석벨트의 착용이 상해정도에 영향을 주는지를 검증하려고 한다딮 승객
의 벨트를 착용할 확률을 땐땲딨X 딽 딱딩 라 하고딬 상해정도가 땜없음딢 일 확률을 땐땲딨Y 딽 딱딩
라고 하자딮 만일 좌석벨트의 착용이 상해정도와 무관하다면딬 승객이 좌석벨트를 착용하고
상해정도도 없을 확률은 다음과 같이 표현될 것이다딮
땐땲딨X 딽 딱, Y 딽 딱딩 딽 땐땲딨X 딽 딱딩 땐땲딨Y 딽 딱딩
위의 식이 성립할 때딬 우리는 “두 확률변수가 서로 독립이다” 라고 말한다딮
두개의 범주형 변수를 가지는 범주형자료에서 두 변수가 서로 독립인지를 검정할 때의
딱딴딱
귀무가설은
H0 딺 땐땲딨X 딽 i, Y 딽 j딩 딽 땐땲딨X 딽 i딩 땐땲딨Y 딽 j딩, i 딽 딱, 딲, j 딽 딱, 딲, 딳, 딴.
이다딮
>
>
>
>
>
>
yesbelt <- c(12813,647,359,42)
nobelt <- c(65963,4000,2642,303)
x<-data.frame(yesbelt,nobelt)
row.names(x)<-c("없음", "경상", "중상", "사망")
res<-chisq.test(x)
res
Pearson’s Chi-squared test
data: data.frame(yesbelt, nobelt)
X-squared = 59.2, df = 3, p-value = 8.61e-13
> res$expected
yesbelt
nobelt
없음 12584.150 66191.85
경상
742.340 3904.66
중상
479.398 2521.60
사망
55.112
289.89
제2절
동일성검정
예를 들어 주사위 던지는 게임을 한다고 하자딮 두 개의 서로 다른 주사위가 있고딬 손님은
딜러보다 높은 수가 나올 경우 이기는 게임이다딮 두 주사위가 공정한지를 확인하기 위하여
딜러의 주사위에 대하여 딲따따 의 게임에서 나온 숫자별 회수와 손님의 주사위에 대하여는
딱따따 회의 게임에서 숫자별로 나온 회수를 아래와 같이 기록하였다딮
딱
주사위 종류 딜러 딳딸
딨X딩
손님 딱딲
딲
딲딶
딴
눈의 수
딳 딴
딲딶 딳딴
딱딷 딱딷
딨Y 딩
딵 딶 합계
딳딱 딴딵 딲따따
딱딸 딳딲 딱따따
주사위를 던졌을 때 눈의 수가 i 가 나올 확률을 딜러의 것과 손님의 것에 대하여 각각
딱딴딲
p1i 와 p2i 라 할 때딬 두 확률이 같은가를 검정하기 위한 귀무가설은 다음과 같다딮
H0 딺 p1i 딽 p2i , i 딽 딱, 딲, 딳, 딴, 딵, 딶.
딱딴딳
딱딴딴
제 23 장
Basic analysis with R
제1절
확률분포 (Probability distributions)
땒 에서 확률분포와 관련된 계산을 위해서 몇가지의 함수를 제공하고 있다딮 확률분포와 관
련된 기능으로는 누적분포함수 딨P 딨X ≤ x딩딩딬 확률밀도함수딬 땱땵땡땮땴땩땬땥 함수 딨땭땩땮x {P 딨X ≤
x딩 > q}딩딬 그리고 랜덤넘버의 생성이 있다딮 아래의 표 딨땔땡땢땬땥 딲딳딮딱딩 는 잘 알려진 확률분포
에 대하여 땒 함수의 기본형과 입력값들이다딮
표 딲딳딮딱딺 확률분포에 따른 땒 함수의 기본형
확률분포
땒 함수 기본형 땡땤땤땩땴땩땯땮땡땬 땡땲땧땵땭땥땮땴땳
땢땥땴땡
땢땥땴땡
땳땨땡땰땥딱딬 땳땨땡땰땥딲딬 땮땣땰
땢땩땮땯땭땩땡땬
땢땩땮땯땭
땳땩땺땥딬 땰땲땯땢
땣땨땩딭땳땱땵땡땲땥땤
땣땨땩땳땱
땤땦딬 땮땣땰
땥땸땰땯땮땥땮땴땩땡땬
땥땸땰
땲땡땴땥
땆
땦
땤땦딱딬 땤땦딲딬 땮땣땰
땧땡땭땭땡
땧땡땭땭땡
땳땨땡땰땥딬 땳땣땡땬땥
땧땥땯땭땥땴땲땩땣
땧땥땯땭
땰땲땯땢
땨땹땰땥땲땧땥땯땭땥땴땲땩땣
땨땹땰땥땲
땭딬 땮딬 땫
땬땯땧땩땳땴땩땣
땬땯땧땩땳
땬땯땣땡땴땩땯땮딬 땳땣땡땬땥
땮땥땧땡땴땩땶땥 땢땩땮땯땭땩땡땬
땮땢땩땮땯땭
땳땩땺땥딬 땰땲땯땢
땮땯땲땭땡땬
땮땯땲땭
땭땥땡땮딬 땳땤
땐땯땩땳땳땯땮
땰땯땩땳
땬땡땭땢땤땡
땓땴땵땤땥땮땴딧땳 땴
땴
땤땦딬 땮땣땰
땵땮땩땦땯땲땭
땵땮땩땦
땭땩땮딬 땭땡땸
확률분포와 관련된 네 가지 기능을 구현하기 위해서는 위 표에 나온 분포에 따른 기본
형 앞에 다음과 같은 접두사를 붙이면 된다딮
딱딴딵
• 땠땰딧 딺 누적분포함수 딨P 딨X ≤ x딩딩
• 땠땤딧 딺 확률밀도함수 딨땤땥땮땳땩땴땹딩
• 땠땱딧 딺 땱땵땡땮땴땩땬땥 함수 딨땭땩땮x {P 딨X ≤ x딩 > q}딩
• 땠땲딧 딺 랜덤넘버의 생성
아래의 예제 프로그램은 X ∼ t딨딱딳딩 을 따를 때딬 P 딨|X| > 딲.딴딳딩 을 구하는 것이다딮
> ## 2-tailed p-value for t distribution
> 2*pt(-2.43, df = 13)
[1] 0.0303309
제2절
기초통계 (기술통계 ; Descriptive statistics)
일변량 자료를 분석할 때딬 맨처음 자료의 수딬 평균딬 분산등 요약통계량 딨땳땵땭땭땡땲땹 땳땴땡땴땩땳땴땩땣땳딩
을 계산하는 것 부터 시작한다딮 이렇게 함으로써 자료의 특징을 개략적으로 짐작할 수 있
고딬 이를 바탕으로 더 세부적인 분석을 가능하게 하기 때문이다딮 아래는 요약통계를 구하는
함수 땳땵땭땭땡땲땹딨딩를 이용하여 기초분석을 하는 땒 코드이다딮
> attach(faithful)
> summary(eruptions)
Min. 1st Qu. Median
Mean 3rd Qu.
1.600
2.163
4.000
3.488
4.454
> fivenum(eruptions)
[1] 1.6000 2.1585 4.0000 4.4585 5.1000
2.1
Max.
5.100
줄기-잎 그림과 상자그림
> stem(eruptions)
The decimal point is 1 digit(s) to the left of the |
16
18
20
22
24
26
|
|
|
|
|
|
070355555588
000022233333335577777777888822335777888
00002223378800035778
0002335578023578
00228
23
딱딴딶
28
30
32
34
36
38
40
42
44
46
48
50
2.2
|
|
|
|
|
|
|
|
|
|
|
|
080
7
2337
250077
0000823577
2333335582225577
0000003357788888002233555577778
03335555778800233333555577778
02222335557780000000023333357778888
0000233357700000023578
00000022335800333
0370
Histogram
땁 땳땴땥땭딭땡땮땤딭땬땥땡땦 땰땬땯땴 땩땳 땬땩땫땥 땡 땨땩땳땴땯땧땲땡땭딬 땡땮땤 땒 땨땡땳 땡 땦땵땮땣땴땩땯땮 땨땩땳땴 땴땯 땰땬땯땴 땨땩땳땴땯땧땲땡땭땳딮
par(mfrow=c(1,2))
hist(log10(islands))
hist(log10(islands), nclass=15, prob=TRUE)
lines(density(log10(islands), bw="SJ"), col="blue")
rug(log10(islands)) # show the actual data points
그림 딲딳딮딱딺 땈땩땳땴땯땧땲땡땭 땥땸땡땭땰땬땥
땔땨땥 땢땡땮땤땷땩땤땴땨 땢땷 땷땡땳 땣땨땯땳땥땮 땢땹 땴땲땩땡땬딭땡땮땤딭땥땲땲땯땲 땡땳 땴땨땥 땤땥땦땡땵땬땴 땧땩땶땥땳 땴땯땯 땭땵땣땨 땳땭땯땯땴땨딭
땩땮땧딮 딨땂땥땴땴땥땲 땡땵땴땯땭땡땴땥땤 땭땥땴땨땯땤땳 땯땦 땢땡땮땤땷땩땤땴땨 땣땨땯땩땣땥 땡땲땥 땡땶땡땩땬땡땢땬땥딬 땡땮땤 땩땮 땴땨땩땳 땥땸땡땭땰땬땥
땢땷 딽 딢땓땊딢 땧땩땶땥땳 땡 땧땯땯땤 땲땥땳땵땬땴딮딩
딱딴딷
2.3
R 그래픽
땒 이 지니고 있는 많은 강점 중에서 한가지를 꼽으라면 그래픽 기능을 둘 수 있다딮 땒 에서
그래프를 그리기 위한 기본함수로 plot()이 있다딮 이 plot()함수를 제대로 이용한다면 왠
만한 대부분의 그래프를 그려낼 수가 있다딮 땒 그래픽 기능과 관련해서는 뒤에서 구체적으
로 다루겠다딮
x<-rnorm(100, sd=2)
y<-0.3 + 2*x + rnorm(100, sd=1)
plot(x)
그림 딲딳딮딲딺 땎땯땲땭땡땬 땥땸땡땭땰땬땥
제3절
분포가정의 진단 : 정규성 검정
표본자료의 경험분포함수 딨땅땭땰땩땲땩땣땡땬 땃땄땆딩 는 땥땣땤땦딨딩함수를 이용해서 구한다딮
> eruptions<-faithful$eruptions
> plot(ecdf(eruptions))
땆땩땧땵땲땥 딲딳딮딴 의 좌측 그림을 보면 경험분포가 표준적인 분포와 크게 차이가 남을 알 수
있다딮 따라서 자료의 값이 딳 땭땩땮땵땴땥땳 보다 큰 것 만을 골라 다시 경험분포함수를 그리고 그
위에 정규분포의 땃땄땆 를 도시하였다 딨땆땩땧땵땲땥 딲딳딮딴 의 우측 그림딩딮 거의 정규분포와 비슷하
다고 보여진다딮
long <- eruptions[eruptions > 3]
plot(ecdf(long), do.points=FALSE, verticals=TRUE)
x <- seq(3, 5.4, 0.01)
lines(x, pnorm(x, mean=mean(long), sd=sqrt(var(long))), lty=3)
딱딴딸
그림 딲딳딮딳딺 경험분포함수
정규성을 체크하기 위한 좀 더 세밀한 시각적인 방법은 땑땵땡땮땴땩땬땥딭땱땵땡땮땴땩땬땥 딨땑딭땑딩 땰땬땯땴
이다딮
par(mfrow=c(1,2))
qqnorm(long); qqline(long)
qqplot(qt(ppoints(250), df = 3), long, xlab = "t(3) Quantiles",
main="Student-t Q-Q plot")
그림 딲딳딮딴딺 땑딭땑 땰땬땯땴
정규성에 대한 검토는 위와 같이 그림으로 나타내는 것 이외에 정규성검정을 통해서
도 할 수 있다딮 땒 은 일변량 자료의 정규성점정을 위하여 땓땨땡땰땩땲땯딭땗땩땬땫 땴땥땳땴딬 땋땯땬땭땯땧땯땲땯땶딭
땓땭땩땲땮땯땶 땴땥땳땴 등을 제공하고 있다딮
> shapiro.test(long)
딱딴딹
Shapiro-Wilk normality test
data: long
W = 0.9793, p-value = 0.01052
> ks.test(long, "pnorm", mean = mean(long), sd = sqrt(var(long)))
One-sample Kolmogorov-Smirnov test
data: long
D = 0.0661, p-value = 0.4284
alternative hypothesis: two.sided
제4절
두 표본의 t 검정 (two-sample tests)
두 모집단의 평균이 같은지를 검정하는 전통적인 방법이 이표본 땴딭땴땥땳땴 이다딮 아래의 자료는
얼음 혼합물의 잠재 열량 딨땣땡땬딯땧땭딩 을 측정한 자료이다 딨땒땩땣땥딻딱딹딹딵딬 땰딮딴딹따딩딮
Method A: 79.98 80.04 80.02 80.04 80.03 80.03 80.04 79.97
80.05 80.03 80.02 80.00 80.02
Method B: 80.02 79.94 79.98 79.97 79.97 80.03 79.95 79.97
먼저 두 표본의 분포를 시각적으로 비교하기 위하여 상자그림을 그려본다딮
A <- scan()
79.98 80.04 80.02
80.05 80.03 80.02
B <- scan()
80.02 79.94 79.98
boxplot(list(A=A,
80.04 80.03 80.03 80.04 79.97
80.00 80.02
79.97 79.97 80.03 79.95 79.97
B=B))
위의 상자그림을 보면 첫번째 그룹 딨땁딩 에서의 열량이 두번째 그룹 딨땂딩 보다 높다고 보여진
다딮 이를 두 모집단간에 평균차가 있는지에 대한 가설검정을 통해서 확인해 보자딮 땒 에서
땴딭땴땥땳땴 를 위한 함수는 t.test()이다딮
> t.test(A, B)
Welch Two Sample t-test
data: A and B
t = 3.2499, df = 12.027, p-value = 0.00694
alternative hypothesis: true difference in means is not equal to 0
딱딵따
그림 딲딳딮딵딺 땂땯땸 땰땬땯땴
95 percent confidence interval:
0.01385526 0.07018320
sample estimates:
mean of x mean of y
80.02077 79.97875
땒 에서의 땴 검정은 기본적으로 두 집단의 분산이 서로 다르다는 전제에서 수행한다딮 두 모
집단의 분산이 같은지 혹은 다른지에 대한 검정을 먼저 해야 한다딮 이 경우의 검정방법은
땆 검정이며딬 이를 위한 땒 함수로는 var.test()이 있다딮
> var.test(A, B)
F test to compare two variances
data: A and B
F = 0.5837, num df = 12, denom df = 7, p-value = 0.3938
alternative hypothesis: true ratio of variances is not equal to 1
95 percent confidence interval:
0.1251097 2.1052687
sample estimates:
ratio of variances
0.5837405
땆딭검정 결과 두 모집단의 분산이 다르다고 할만한 근거는 없다고 판단된다딮 따라서 분산이
동일한 경우에 대한 땴딭땴땥땳땴 를 다음과 같이 한다딮
> t.test(A, B, var.equal=TRUE)
딱딵딱
Two Sample t-test
data: A and B
t = 3.4722, df = 19, p-value = 0.002551
alternative hypothesis: true difference in means is not equal to 0
95 percent confidence interval:
0.01669058 0.06734788
sample estimates:
mean of x mean of y
80.02077 79.97875
위의 모든 땴 검정은 기본적으로 두 표본이 정규분포를 따른다는 가정에서 출발한다딮 따
라서 정규성을 만족하는지를 체크하여야 한다딮 정규성에 대한 진단은 앞 소절 딨딳딩 에서 처럼
시각적인 방법 혹은 가설검정을 통해서 할 수 있다딮
> plot(ecdf(A), do.points=FALSE, verticals=TRUE, xlim=range(A, B))
> plot(ecdf(B), do.points=FALSE, verticals=TRUE, add=TRUE)
다음은 두 분포가 서로 동일한지를 검정하는 땋땯땬땭땯땧땯땲땯땶딭땓땭땩땲땮땯땶 땴땥땳땴 이다딮
> ks.test(A, B)
Two-sample Kolmogorov-Smirnov test
data: A and B
D = 0.5962, p-value = 0.05919
alternative hypothesis: two-sided
Warning message:
cannot compute correct p-values with ties in: ks.test(A, B)
제5절
대응비교 (paired t-test)
이변량자료에 대한 대응비교 딨땰땡땩땲땥땤 땴딭땴땥땳땴딩 역시 t.test()함수를 이용한다딮 다만딬 땒 함수
t.test()에는 아래와 같은 많은 인수들이 있으며딬 이 함수의 인수 중에 땰땡땩땲땥땤딽땔땒땕땅 로
지정하기만 하면 된다딮
t.test(x, y = NULL,
alternative = c("two.sided", "less", "greater"),
mu = 0, paired = FALSE, var.equal = FALSE,
conf.level = 0.95, ...)
딱딵딲
제6절
비율검정 및 카이제곱검정
smokers <- c( 83, 90, 129, 70 )
patients <- c( 86, 93, 136, 82 )
prop.test(smokers, patients)
## Effect of simulating p-values
x <- matrix(c(12, 5, 7, 7), nc = 2)
chisq.test(x)$p.value
# 0.4233
chisq.test(x, simulate.p.value = TRUE, B = 10000)$p.value
# around 0.29!
딱딵딳
딱딵딴
제 24 장
Linear models
선형회귀모형을 적합시키기 위한 땒 함수는 lm()이고딬 기본형은 다음과 같다딮
fitted.model <- lm(formula, data = data.frame)
예를 들어딬 땰땲땯땤땵땣땴땩땯땮 데이터셋을 이용하여 종속변수가 y 이고 설명변수가 x1 과 x2 이며
절편항이 딨땩땮땴땥땲땣땥땰땴 땴땥땲땭딩 이 포함된 중회귀 모형을 적합시키는 땒 코드는 다음과 같다딮
> fm2 <- lm(y ~ x1 + x2, data = production)
제1절
모형 객체와 관련된 일반함수 (Generic function)
lm()을 이용하여 모형을 적합한 결과는 모형객체에 저장할 수 있는 데딬 모형객체의 클래
스는 딢땬땭딢 이고 class(data.onhect) 함수로 확인할 수 있다딮 딢땬땭딢 객체에는 여러 정보
가 포함되어 있는 데딬 땒 은 모형객체에서 이러한 정보들을 추출하는 다음과 같은 일반함수
딨땧땥땮땥땲땩땣 땦땵땮땣땴땩땯땮딩 를 제공한다딮
add1
alias
anova
coef
deviance
drop1
effects
family
formula
kappa
labels
plot
predict step
print
summary
proj
vcov
residuals
아래는 위에 나열된 일반함수들 중 많이 사용되는 함수에 대한 설명이다딮
딱딮 anova(object1, object2) 딺 땃땯땭땰땡땲땥 땡 땳땵땢땭땯땤땥땬 땷땩땴땨 땡땮 땯땵땴땥땲 땭땯땤땥땬 땡땮땤 땰땲땯딭
땤땵땣땥 땡땮 땡땮땡땬땹땳땩땳 땯땦 땶땡땲땩땡땮땣땥 땴땡땢땬땥딮
딲딮 coef(object), coefficients(object)딺 땅땸땴땲땡땣땴 땴땨땥 땲땥땧땲땥땳땳땩땯땮 땣땯땥딎땣땩땥땮땴 딨땭땡땴땲땩땸딩딮
딳딮 deviance(object)딺 땒땥땳땩땤땵땡땬 땳땵땭 땯땦 땳땱땵땡땲땥땳딬 땷땥땩땧땨땴땥땤 땩땦 땡땰땰땲땯땰땲땩땡땴땥딮
딱딵딵
딴딮 formula(object)딺 땅땸땴땲땡땣땴 땴땨땥 땭땯땤땥땬 땦땯땲땭땵땬땡딮
딵딮 plot(object)딺 땐땲땯땤땵땣땥 땦땯땵땲 땰땬땯땴땳딬 땳땨땯땷땩땮땧 땲땥땳땩땤땵땡땬땳딬 딌땴땴땥땤 땶땡땬땵땥땳 땡땮땤 땳땯땭땥 땤땩땡땧딭
땮땯땳땴땩땣땳딮
딶딮 predict(object, newdata=data.frame)딺 땔땨땥 땤땡땴땡 땦땲땡땭땥 땳땵땰땰땬땩땥땤 땭땵땳땴 땨땡땶땥 땶땡땲땩딭
땡땢땬땥땳 땳땰땥땣땩딌땥땤 땷땩땴땨 땴땨땥 땳땡땭땥 땬땡땢땥땬땳 땡땳 땴땨땥 땯땲땩땧땩땮땡땬딮 땔땨땥 땶땡땬땵땥 땩땳 땡 땶땥땣땴땯땲 땯땲 땭땡땴땲땩땸
땯땦 땰땲땥땤땩땣땴땥땤 땶땡땬땵땥땳 땣땯땲땲땥땳땰땯땮땤땩땮땧 땴땯 땴땨땥 땤땥땴땥땲땭땩땮땩땮땧 땶땡땲땩땡땢땬땥 땶땡땬땵땥땳 땩땮 땤땡땴땡딮땦땲땡땭땥딮
딷딮 print(object)딺 땐땲땩땮땴 땡 땣땯땮땣땩땳땥 땶땥땲땳땩땯땮 땯땦 땴땨땥 땯땢땪땥땣땴딮 땍땯땳땴 땯땦땴땥땮 땵땳땥땤 땩땭땰땬땩땣땩땴땬땹딮
딸딮 residuals(object), resid(object)딺 땅땸땴땲땡땣땴 땴땨땥 딨땭땡땴땲땩땸 땯땦딩 땲땥땳땩땤땵땡땬땳딬 땷땥땩땧땨땴땥땤
땡땳 땡땰땰땲땯땰땲땩땡땴땥딮
딹딮 step(object)딺 땓땥땬땥땣땴 땡 땳땵땩땴땡땢땬땥 땭땯땤땥땬 땢땹 땡땤땤땩땮땧 땯땲 땤땲땯땰땰땩땮땧 땴땥땲땭땳 땡땮땤 땰땲땥땳땥땲땶땩땮땧
땨땩땥땲땡땲땣땨땩땥땳딮 땔땨땥 땭땯땤땥땬 땷땩땴땨 땴땨땥 땳땭땡땬땬땥땳땴 땶땡땬땵땥 땯땦 땁땉땃 딨땁땫땡땩땫땥딧땳 땁땮 땉땮땦땯땲땭땡땴땩땯땮
땃땲땩땴땥땲땩땯땮딩 땤땩땳땣땯땶땥땲땥땤 땩땮 땴땨땥 땳땴땥땰땷땩땳땥 땳땥땡땲땣땨 땩땳 땲땥땴땵땲땮땥땤딮
딱따딮 summary(object)딺 땐땲땩땮땴 땡 땣땯땭땰땲땥땨땥땮땳땩땶땥 땳땵땭땭땡땲땹 땯땦 땴땨땥 땲땥땳땵땬땴땳 땯땦 땴땨땥 땲땥땧땲땥땳땳땩땯땮
땡땮땡땬땹땳땩땳딮
딱딱딮 vcov(object)딺 땒땥땴땵땲땮땳 땴땨땥 땶땡땲땩땡땮땣땥딭땣땯땶땡땲땩땡땮땣땥 땭땡땴땲땩땸 땯땦 땴땨땥 땭땡땩땮 땰땡땲땡땭땥땴땥땲땳 땯땦
땡 딌땴땴땥땤 땭땯땤땥땬 땯땢땪땥땣땴딮
제2절
Analysis of variance(ANOVA) and model comparison
땔땨땥 땭땯땤땥땬 딌땴땴땩땮땧 땦땵땮땣땴땩땯땮 땡땯땶딨땦땯땲땭땵땬땡딬 땤땡땴땡딽땤땡땴땡딮땦땲땡땭땥딩 땯땰땥땲땡땴땥땳 땡땴 땴땨땥 땳땩땭땰땬땥땳땴 땬땥땶땥땬
땩땮 땡 땶땥땲땹 땳땩땭땩땬땡땲 땷땡땹 땴땯 땴땨땥 땦땵땮땣땴땩땯땮 땬땭딨딩딬 땡땮땤 땭땯땳땴 땯땦 땴땨땥 땧땥땮땥땲땩땣 땦땵땮땣땴땩땯땮땳 땬땩땳땴땥땤 땩땮
땴땨땥 땴땡땢땬땥 땩땮 땇땥땮땥땲땩땣 땦땵땮땣땴땩땯땮땳 땦땯땲 땥땸땴땲땡땣땴땩땮땧 땭땯땤땥땬 땩땮땦땯땲땭땡땴땩땯땮 땡땰땰땬땹딮
땉땴 땳땨땯땵땬땤 땢땥 땮땯땴땥땤 땴땨땡땴 땩땮 땡땤땤땩땴땩땯땮 땡땯땶딨딩 땡땬땬땯땷땳 땡땮 땡땮땡땬땹땳땩땳 땯땦 땭땯땤땥땬땳 땷땩땴땨 땭땵땬땴땩땰땬땥
땥땲땲땯땲 땳땴땲땡땴땡 땳땵땣땨 땡땳 땳땰땬땩땴 땰땬땯땴 땥땸땰땥땲땩땭땥땮땴땳딬 땯땲 땢땡땬땡땮땣땥땤 땩땮땣땯땭땰땬땥땴땥 땢땬땯땣땫 땤땥땳땩땧땮땳 땷땩땴땨
땲땥땣땯땶땥땲땹 땯땦 땩땮땴땥땲딭땢땬땯땣땫 땩땮땦땯땲땭땡땴땩땯땮딮 땔땨땥 땭땯땤땥땬 땦땯땲땭땵땬땡
response ~ mean.formula + Error(strata.formula)
땳땰땥땣땩딌땥땳 땡 땭땵땬땴땩딭땳땴땲땡땴땵땭 땥땸땰땥땲땩땭땥땮땴 땷땩땴땨 땥땲땲땯땲 땳땴땲땡땴땡 땤땥딌땮땥땤 땢땹 땴땨땥 땳땴땲땡땴땡딮땦땯땲땭땵땬땡딮 땉땮
땴땨땥 땳땩땭땰땬땥땳땴 땣땡땳땥딬 땳땴땲땡땴땡딮땦땯땲땭땵땬땡 땩땳 땳땩땭땰땬땹 땡 땦땡땣땴땯땲딬 땷땨땥땮 땩땴 땤땥딌땮땥땳 땡 땴땷땯 땳땴땲땡땴땡 땥땸땰땥땲땩딭
땭땥땮땴딬 땮땡땭땥땬땹 땢땥땴땷땥땥땮 땡땮땤 땷땩땴땨땩땮 땴땨땥 땬땥땶땥땬땳 땯땦 땴땨땥 땦땡땣땴땯땲딮
땆땯땲 땥땸땡땭땰땬땥딬 땷땩땴땨 땡땬땬 땤땥땴땥땲땭땩땮땩땮땧 땶땡땲땩땡땢땬땥땳 땦땡땣땴땯땲땳딬 땡 땭땯땤땥땬 땦땯땲땭땵땬땡 땳땵땣땨 땡땳 땴땨땡땴 땩땮딺
딱딵딶
> fm <- aov(yield ~ v + n*p*k + Error(farms/blocks), data=farm.data)
땷땯땵땬땤 땴땹땰땩땣땡땬땬땹 땢땥 땵땳땥땤 땴땯 땤땥땳땣땲땩땢땥 땡땮 땥땸땰땥땲땩땭땥땮땴 땷땩땴땨 땭땥땡땮 땭땯땤땥땬 땶 딫 땮딪땰딪땫 땡땮땤
땴땨땲땥땥 땥땲땲땯땲 땳땴땲땡땴땡딬 땮땡땭땥땬땹 땜땢땥땴땷땥땥땮 땦땡땲땭땳딢딬 땜땷땩땴땨땩땮 땦땡땲땭땳딬 땢땥땴땷땥땥땮 땢땬땯땣땫땳딢 땡땮땤 땜땷땩땴땨땩땮
땢땬땯땣땫땳딢딮
제3절
ANOVA tables
땎땯땴땥 땡땬땳땯 땴땨땡땴 땴땨땥 땡땮땡땬땹땳땩땳 땯땦 땶땡땲땩땡땮땣땥 땴땡땢땬땥 딨땯땲 땴땡땢땬땥땳딩 땡땲땥 땦땯땲 땡 땳땥땱땵땥땮땣땥 땯땦 딌땴땴땥땤 땭땯땤딭
땥땬땳딮 땔땨땥 땳땵땭땳 땯땦 땳땱땵땡땲땥땳 땳땨땯땷땮 땡땲땥 땴땨땥 땤땥땣땲땥땡땳땥 땩땮 땴땨땥 땲땥땳땩땤땵땡땬 땳땵땭땳 땯땦 땳땱땵땡땲땥땳 땲땥땳땵땬땴땩땮땧
땦땲땯땭 땡땮 땩땮땣땬땵땳땩땯땮 땯땦 땴땨땡땴 땴땥땲땭 땩땮 땴땨땥 땭땯땤땥땬 땡땴 땴땨땡땴 땰땬땡땣땥 땩땮 땴땨땥 땳땥땱땵땥땮땣땥딮 땈땥땮땣땥 땯땮땬땹
땦땯땲 땯땲땴땨땯땧땯땮땡땬 땥땸땰땥땲땩땭땥땮땴땳 땷땩땬땬 땴땨땥 땯땲땤땥땲 땯땦 땩땮땣땬땵땳땩땯땮 땢땥 땩땮땣땯땮땳땥땱땵땥땮땴땩땡땬딮
땆땯땲 땭땵땬땴땩땳땴땲땡땴땵땭 땥땸땰땥땲땩땭땥땮땴땳 땴땨땥 땰땲땯땣땥땤땵땲땥 땩땳 딌땲땳땴 땴땯 땰땲땯땪땥땣땴 땴땨땥 땲땥땳땰땯땮땳땥 땯땮땴땯 땴땨땥
땥땲땲땯땲 땳땴땲땡땴땡딬 땡땧땡땩땮 땩땮 땳땥땱땵땥땮땣땥딬 땡땮땤 땴땯 딌땴 땴땨땥 땭땥땡땮 땭땯땤땥땬 땴땯 땥땡땣땨 땰땲땯땪땥땣땴땩땯땮딮 땆땯땲 땦땵땲땴땨땥땲
땤땥땴땡땩땬땳딬 땳땥땥 땃땨땡땭땢땥땲땳 딦 땈땡땳땴땩땥 딨딱딹딹딲딩딮
땁 땭땯땲땥 딍땥땸땩땢땬땥 땡땬땴땥땲땮땡땴땩땶땥 땴땯 땴땨땥 땤땥땦땡땵땬땴 땦땵땬땬 땁땎땏땖땁 땴땡땢땬땥 땩땳 땴땯 땣땯땭땰땡땲땥 땴땷땯 땯땲
땭땯땲땥 땭땯땤땥땬땳 땤땩땲땥땣땴땬땹 땵땳땩땮땧 땴땨땥 땡땮땯땶땡딨딩 땦땵땮땣땴땩땯땮딮
> anova(fitted.model.1, fitted.model.2, ...)
땔땨땥 땤땩땳땰땬땡땹 땩땳 땴땨땥땮 땡땮 땁땎땏땖땁 땴땡땢땬땥 땳땨땯땷땩땮땧 땴땨땥 땤땩딋땥땲땥땮땣땥땳 땢땥땴땷땥땥땮 땴땨땥 딌땴땴땥땤 땭땯땤딭
땥땬땳 땷땨땥땮 딌땴땴땥땤 땩땮 땳땥땱땵땥땮땣땥딮 땔땨땥 딌땴땴땥땤 땭땯땤땥땬땳 땢땥땩땮땧 땣땯땭땰땡땲땥땤 땷땯땵땬땤 땵땳땵땡땬땬땹 땢땥 땡땮 땨땩땥땲딭
땡땲땣땨땩땣땡땬 땳땥땱땵땥땮땣땥딬 땯땦 땣땯땵땲땳땥딮 땔땨땩땳 땤땯땥땳 땮땯땴 땧땩땶땥 땤땩딋땥땲땥땮땴 땩땮땦땯땲땭땡땴땩땯땮 땴땯 땴땨땥 땤땥땦땡땵땬땴딬 땢땵땴
땲땡땴땨땥땲 땭땡땫땥땳 땩땴 땥땡땳땩땥땲 땴땯 땣땯땭땰땲땥땨땥땮땤 땡땮땤 땣땯땮땴땲땯땬딮
3.0.1
Updating fitted models
땔땨땥 땵땰땤땡땴땥딨딩 땦땵땮땣땴땩땯땮 땩땳 땬땡땲땧땥땬땹 땡 땣땯땮땶땥땮땩땥땮땣땥 땦땵땮땣땴땩땯땮 땴땨땡땴 땡땬땬땯땷땳 땡 땭땯땤땥땬 땴땯 땢땥 딌땴땴땥땤
땴땨땡땴 땤땩딋땥땲땳 땦땲땯땭 땯땮땥 땰땲땥땶땩땯땵땳땬땹 딌땴땴땥땤 땵땳땵땡땬땬땹 땢땹 땪땵땳땴 땡 땦땥땷 땡땤땤땩땴땩땯땮땡땬 땯땲 땲땥땭땯땶땥땤 땴땥땲땭땳딮
땉땴땳 땦땯땲땭 땩땳
> new.model <- update(old.model, new.formula)
땉땮 땴땨땥 땮땥땷딮땦땯땲땭땵땬땡 땴땨땥 땳땰땥땣땩땡땬 땮땡땭땥 땣땯땮땳땩땳땴땩땮땧 땯땦 땡 땰땥땲땩땯땤딬 땠딮딧딬 땯땮땬땹딬 땣땡땮 땢땥 땵땳땥땤 땴땯
땳땴땡땮땤 땦땯땲 땜땴땨땥 땣땯땲땲땥땳땰땯땮땤땩땮땧 땰땡땲땴 땯땦 땴땨땥 땯땬땤 땭땯땤땥땬 땦땯땲땭땵땬땡딢딮 땆땯땲 땥땸땡땭땰땬땥딬
> fm05 <- lm(y ~ x1 + x2 + x3 + x4 + x5, data = production)
> fm6 <- update(fm05, . ~ . + x6)
> smf6 <- update(fm6, sqrt(.) ~ .)
딱딵딷
땷땯땵땬땤 딌땴 땡 딌땶땥 땶땡땲땩땡땴땥 땭땵땬땴땩땰땬땥 땲땥땧땲땥땳땳땩땯땮 땷땩땴땨 땶땡땲땩땡땢땬땥땳 딨땰땲땥땳땵땭땡땢땬땹딩 땦땲땯땭 땴땨땥 땤땡땴땡
땦땲땡땭땥 땰땲땯땤땵땣땴땩땯땮딬 딌땴 땡땮 땡땤땤땩땴땩땯땮땡땬 땭땯땤땥땬 땩땮땣땬땵땤땩땮땧 땡 땳땩땸땴땨 땲땥땧땲땥땳땳땯땲 땶땡땲땩땡땢땬땥딬 땡땮땤 딌땴 땡
땶땡땲땩땡땮땴 땯땮 땴땨땥 땭땯땤땥땬 땷땨땥땲땥 땴땨땥 땲땥땳땰땯땮땳땥 땨땡땤 땡 땳땱땵땡땲땥 땲땯땯땴 땴땲땡땮땳땦땯땲땭 땡땰땰땬땩땥땤딮
땎땯땴땥 땥땳땰땥땣땩땡땬땬땹 땴땨땡땴 땩땦 땴땨땥 땤땡땴땡딽 땡땲땧땵땭땥땮땴 땩땳 땳땰땥땣땩딌땥땤 땯땮 땴땨땥 땯땲땩땧땩땮땡땬 땣땡땬땬 땴땯 땴땨땥
땭땯땤땥땬 딌땴땴땩땮땧 땦땵땮땣땴땩땯땮딬 땴땨땩땳 땩땮땦땯땲땭땡땴땩땯땮 땩땳 땰땡땳땳땥땤 땯땮 땴땨땲땯땵땧땨 땴땨땥 딌땴땴땥땤 땭땯땤땥땬 땯땢땪땥땣땴 땴땯
땵땰땤땡땴땥딨딩 땡땮땤 땩땴땳 땡땬땬땩땥땳딮
땔땨땥 땮땡땭땥 땠딮딧 땣땡땮 땡땬땳땯 땢땥 땵땳땥땤 땩땮 땯땴땨땥땲 땣땯땮땴땥땸땴땳딬 땢땵땴 땷땩땴땨 땳땬땩땧땨땴땬땹 땤땩딋땥땲땥땮땴 땭땥땡땮땩땮땧딮
땆땯땲 땥땸땡땭땰땬땥
> fmfull <- lm(y ~ . , data = production)
땷땯땵땬땤 딌땴 땡 땭땯땤땥땬 땷땩땴땨 땲땥땳땰땯땮땳땥 땹 땡땮땤 땲땥땧땲땥땳땳땯땲 땶땡땲땩땡땢땬땥땳 땡땬땬 땯땴땨땥땲 땶땡땲땩땡땢땬땥땳 땩땮 땴땨땥
땤땡땴땡 땦땲땡땭땥 땰땲땯땤땵땣땴땩땯땮딮
땏땴땨땥땲 땦땵땮땣땴땩땯땮땳 땦땯땲 땥땸땰땬땯땲땩땮땧 땩땮땣땲땥땭땥땮땴땡땬 땳땥땱땵땥땮땣땥땳 땯땦 땭땯땤땥땬땳 땡땲땥 땡땤땤딱딨딩딬 땤땲땯땰딱딨딩
땡땮땤 땳땴땥땰딨딩딮 땔땨땥 땮땡땭땥땳 땯땦 땴땨땥땳땥 땧땩땶땥 땡 땧땯땯땤 땣땬땵땥 땴땯 땴땨땥땩땲 땰땵땲땰땯땳땥딬 땢땵땴 땦땯땲 땦땵땬땬 땤땥땴땡땩땬땳 땳땥땥
땴땨땥 땯땮딭땬땩땮땥 땨땥땬땰딮
딱딵딸
찾아보기
감마분포 딨땧땡땭땭땡 땤땩땳땴땲땩땢땵땴땩땯땮딩딬 딱딲딸
이상치 딨땯땵땴땬땩땥땲딩딬 딱딳딵
값에 의한 호출 딨땃땡땬땬 땢땹 땖땡땬땵땥딩딬 딶딹
이항분포 딨땢땩땮땯땭땩땡땬 땤땩땳땴땲땩땢땵땴땩땯땮딩딬 딱딲딴
검정통계량 딨땴땥땳땴 땳땴땡땴땩땳땴땩땣딩딬 딱딴따
일표본 땴 검정 딨땯땮땥 땳땡땭땰땬땥 땴딭땴땥땳땴딩딬 딱딳딸
구조체 포인터의 메모리 할당딬 딶딳
자유도딬 딱딴딱
구조체 딨땳땴땲땵땣땴땵땲땥딩딬 딵딹
자유도 딨땤땥땧땲땥땥 땯땦 땦땲땥땥땤땯땭딩딬 딱딳딸
균등분포 딨땵땮땩땦땯땲땭 땤땩땳땴땲땩땢땵땴땩땯땮딩딬 딱딲딳
적률 딨땭땯땭땥땮땴딩딬 딱딲딲
근원사건딬 딱딱딹
정규분포 딨땮땯땲땭땡땬 땤땩땳땴땲땩땢땵땴땩땯땮딩딬 딱딲딶
기대값 딨땥땸땰땥땣땴땡땴땩땯땮딩딬 딱딲딱
조건 연산자딬 딳딷
누적분포함수 딨땣땵땭땵땬땡땴땩땶땥 땤땩땳땴땲땩땢땵땴땩땯땮 땦땵땮땣딭 지수분포 딨땥땸땰땯땮땥땮땴땩땡땬 땤땩땳땴땲땩땢땵땴땩땯땮딩딬 딱딲딸
땴땩땯땮딻 땣딮땤딮땦딮딩딬 딱딲따
참조에 의한 호출 딨땃땡땬땬 땢땹 땒땥땦땥땲땥땮땣땥딩딬 딷따
대응비교 딨땐땡땩땲땥땤 땴딭땴땥땳땴딩딬 딱딴따
콜모고로프 딨땋땯땬땭땯땧땯땲땯땶딩딬 딱딲따
대응비교 딨땰땡땩땲땥땤 땴딭땴땥땳땴딩딬 딱딵딲
포인터딬 딵따
독립성검정딬 딱딴딱
포인터 변수딬 딵따
동일성검정딬 딱딴딲
포인터의 형딬 딵딱
동적 메모리 할당딬 딵딴
표본 딨땳땡땭땰땬땥딩딬 딱딱딹
라플라스 딨때땡땰땬땡땣땥딩딬 딱딱딹
표본공간 딨땳땡땭땰땬땥 땳땰땡땣땥딩딬 딱딱딹
매개변수딬 딶딸
표본분산딬 딱딲딲딬 딱딳딸
메모리 영역딬 딵딳
표본평균딬 딱딲딲딬 딱딳딸
메모리 해제딬 딵딶
함수의 호출딬 딶딹
멤버참조딬 딶딳
확률 딨땰땲땯땢땡땢땩땬땩땴땹딩딬 딱딱딹
모집단 딨땰땯땰땵땬땡땴땩땯땮딩딬 딱딱딹
확률밀도함수딬 딱딲딱
배열딬 딴딹
확률밀도함수 딨땰땲땯땢땡땢땩땬땩땴땹 땤땥땮땳땩땴땹 땦땵땮땣땴땩땯땮딻 땰딮땤딮땦딮딩딬
번지 연산자 딨딦딬 딪딩딬 딵딱
딱딲딱
베르누이분포딬 딱딲딴
확률변수딬 딱딲따
베르누이실험딬 딱딲딴
확률변수 딨땲땡땮땤땯땭 땶땡땲땩땡땢땬땥딩딬 딱딲따
사건 딨땥땶땥땮땴딩딬 딱딱딹
확률분포딬 딱딲따
삼항 연산자딬 딳딷
확률분포 딨땰땲땯땢땡땢땩땬땩땴땹 땤땩땳땴땲땩땢땵땴땩땯땮딩딬 딱딲따
쉼표연산자와 땦땯땲딨딩딬 딴딵
확률질량함수딬 딱딲딱
스택 딨땓땴땡땣땫딩딬 딵딳
확률질량함수 딨땰땲땯땢땡땢땩땬땩땴땹 땭땡땳땳 땦땵땮땣땴땩땯땮딻 땰딮땭딮땦딮딩딬
딱딲딱
유의 확률 딨땰딭땶땡땬땵땥딩딬 딱딳딹
힙 딨땈땥땡땰딩딬 딵딳
유의수준딬 딱딳딹
딱딵딹
땂땯땸딭땍땵땬땬땥땲 변환딬 딱딲딷
땂땯땸땰땬땯땴딨상자그림딩딬 딱딳딵
땢땲땥땡땫딬 딴딶
땣땡땬땬땯땣딨딩딬 딵딵
땣땯땮땴땩땮땵땥딬 딴딶
땤땯 딮딮딮 땷땨땩땬땥 문딬 딴딴
땥땬땳땥딬 딴딱
땦땯땲 문딬 딴딵
땩땦딨딩문딬 딴딱
땉땑땒딨땩땮땴땥땲땱땵땡땲땴땩땬땥 땲땡땮땧땥딻 딴 분위수범위딩딬 딱딳딵
땭땡땬땬땯땣딨딩딬 딵딴
땲땥땴땵땲땮딬 딴딶
땳땴땲땣땰땹딨딩딬 딵딹
땳땷땩땴땣땨딬 딴딲
땴 통계량딬 딱딳딸
땴 검정 딨땴딭땴땥땳땴딩딬 딱딳딸
땷땨땩땬땥딬 딴딳
딱딶따