├── _config.yml ├── 2장. 기본적인 확률도구 5개 ├── 표 1. 지수분포로부터 임의수 발생시키기 │ ├── exp.R │ └── exp.iml ├── README.md ├── 표 6. 이변량정규분포 확률의 몬테칼로 계산 │ ├── BN.R │ └── BN.iml ├── 표 2. 표준정규분포로부터 임의수 발생시키기 │ ├── normal.R │ └── normal.iml ├── 표 4. 이항분포로부터 임의수 발생시키기 │ ├── b.R │ └── b.iml ├── 표 5. 포아송 분포로부터 임의수 발생시키기 │ ├── poisson.R │ └── poisson.iml ├── 표 3. 음이항분포로부터 임의수 발생시키기 │ ├── nb.R │ └── nb.iml └── 표 7. 몬테칼로 방법으로 t 분포의 분위수 구하기 │ ├── ttt.R │ └── ttt.iml ├── 8장. 통계적 모형론 ├── 표 2. 포도 자료; 10월의 산출량(Y)과 7월의 송이 수 │ └── 표 2.R ├── README.md ├── 표 3. 독성실험 자료 │ └── 표 3.R ├── 표 1. Q의 상위 5% 분위수 계산을 위한 프로그램 │ ├── tukey.R │ └── tukey.iml └── 표 4. 독성실험 자료의 로짓 모형 분석을 위한 프로그램 │ ├── logit.R │ └── logit.iml ├── 5장. 점 추정론 ├── README.md ├── 표 1. 심프슨의 1／3 규칙에 의한 수치적분 │ ├── simpson.R │ └── simpson.iml ├── 표 2. 오염정규분포에서 두 통게량 T1과 T2의 비교 │ ├── contam2.R │ └── contam2.iml └── 표 3. mle hat_theta의 모의분를 만들기 위한 프로그램(theta=0.5, n=40) │ ├── angular.R │ └── angular.iml ├── 6장. 가설 검증론 ├── README.md └── 표 1. 대표본 검증통계량의 몬테칼로 p-값 계산 │ ├── glrt.R │ └── glrt.iml ├── 7장. 구간 추정론 ├── README.md ├── 표 1. 이항표본에서 신뢰구간의 상한을 구하기 위한 프로그램 │ ├── conf1.R │ └── conf1.iml ├── 표 3. 근사적 신뢰구간의 포함확률 평가를 위한 프로그램 │ ├── conf3.R │ └── conf3.iml ├── 표 4. 특수 정규표본에서 신뢰구간을 구하기 위한 프로그램 │ ├── conf4.iml │ └── conf4.R └── 표 2. 포아송 표본에서 신뢰구간을 구하기 위한 프로그램 │ ├── conf2.R │ └── conf2.iml ├── 9장. 특수 토픽 ├── README.md ├── 표 3. 상관계수 r의 임의순열 분포를 구하기 위한 프로그램 │ ├── permute.R │ └── permute.iml ├── 표 1. 후버의 M-추정치를 구하기 위한 프로그램 │ ├── robust.R │ └── robust.iml └── 표 2. M-추정치의 붓스트랩 분포를 구하기 위한 프로그램 │ ├── boots.R │ └── boots.iml ├── 3장. 재미있는 확률문제 5개 ├── README.md ├── 표 3. 뷔퐁의 바늘 문제 풀이를 위한 몬테칼로 프로그램 │ ├── needle.R │ └── needle.iml ├── 표 2. 쿠폰 수집 문제를 위한 몬테칼로 프로그램 │ ├── COUPON.R │ └── COUPON.IML ├── 표 1. 도박꾼의 파산 문제를 위한 몬테칼로 프로그램 │ ├── RUIN.R │ └── RUIN.IML ├── 표 4. Let's Make a Deal 문제 풀이를 위한 몬테칼로 프로그램 │ ├── lmad.R │ └── lmad.iml └── 표 5. 산불과정을 보기 위한 몬테칼로 프로그램 │ ├── fire.iml │ └── fire.R ├── 4장. 가능도(Likelihood); 개념, 계산, 속성 ├── README.md ├── 표 2. 뉴튼-라프슨 방법으로 최대가능도 추정값 구하기 │ ├── mle.R │ └── mle.iml ├── 표 1. 이분법으로 1／k 규칙에 의한 구간 구하기 │ ├── bike.R │ └── bike.iml └── 표 3. 2개 파라미터의 최대가능도 추정; 뉴튼-라프슨 방법 │ ├── mle2.R │ └── mle2.iml └── README.md /_config.yml: -------------------------------------------------------------------------------- 1 | theme: jekyll-theme-midnight -------------------------------------------------------------------------------- /2장. 기본적인 확률도구 5개/표 1. 지수분포로부터 임의수 발생시키기/exp.R: -------------------------------------------------------------------------------- 1 | Nrepeat = 100 2 | sum = 0 3 | 4 | for (i in 1:Nrepeat) 5 | { 6 | u = runif(1) 7 | x = -2*log(1-u) 8 | print(paste("u: ", u, " x: ", x, sep="")) 9 | sum = sum+x 10 | } 11 | 12 | mean = sum / Nrepeat 13 | mean -------------------------------------------------------------------------------- /8장. 통계적 모형론/표 2. 포도 자료; 10월의 산출량(Y)과 7월의 송이 수/표 2.R: -------------------------------------------------------------------------------- 1 | ### 원래 SAS 코드가 없습니다. : 유재성 2 | 3 | Y = c(5.6, 3.2, 4.5, 4.2, 5.2, 2.7, 4.8, 4.9, 4.7, 4.1, 4.4, 5.4) 4 | X = c(116, 83, 111, 98, 116, 80, 125, 116, 117, 93, 107, 122) 5 | 6 | plot(X, Y) 7 | model = lm(Y~X) 8 | abline(model) -------------------------------------------------------------------------------- /5장. 점 추정론/README.md: -------------------------------------------------------------------------------- 1 | 허명회 선생님의 <수리통계학 강의> 5장 링크는 다음과 같습니다. 2 | 3 | http://www.statground.org/index.php?mid=MyungHoeHuh&document_srl=8943 4 | 5 | 다만 제가 나름대로 공부하며 작성한 것이다보니, 원 저자의 의도와는 다른 오류가 있을 수 있습니다. 혹시 그러한 오류가 발견되면, 연락을 주시면 감사드립니다. 바로 고치도록 하겠습니다. 6 | 7 | 유재성 (praster1@gmail.com) -------------------------------------------------------------------------------- /6장. 가설 검증론/README.md: -------------------------------------------------------------------------------- 1 | 허명회 선생님의 <수리통계학 강의> 6장 링크는 다음과 같습니다. 2 | 3 | http://www.statground.org/index.php?mid=MyungHoeHuh&document_srl=8989 4 | 5 | 다만 제가 나름대로 공부하며 작성한 것이다보니, 원 저자의 의도와는 다른 오류가 있을 수 있습니다. 혹시 그러한 오류가 발견되면, 연락을 주시면 감사드립니다. 바로 고치도록 하겠습니다. 6 | 7 | 유재성 (praster1@gmail.com) -------------------------------------------------------------------------------- /7장. 구간 추정론/README.md: -------------------------------------------------------------------------------- 1 | 허명회 선생님의 <수리통계학 강의> 6장 링크는 다음과 같습니다. 2 | 3 | http://www.statground.org/index.php?mid=MyungHoeHuh&document_srl=8993 4 | 5 | 다만 제가 나름대로 공부하며 작성한 것이다보니, 원 저자의 의도와는 다른 오류가 있을 수 있습니다. 혹시 그러한 오류가 발견되면, 연락을 주시면 감사드립니다. 바로 고치도록 하겠습니다. 6 | 7 | 유재성 (praster1@gmail.com) -------------------------------------------------------------------------------- /8장. 통계적 모형론/README.md: -------------------------------------------------------------------------------- 1 | 허명회 선생님의 <수리통계학 강의> 8장 링크는 다음과 같습니다. 2 | 3 | http://www.statground.org/index.php?mid=MyungHoeHuh&document_srl=9020 4 | 5 | 다만 제가 나름대로 공부하며 작성한 것이다보니, 원 저자의 의도와는 다른 오류가 있을 수 있습니다. 혹시 그러한 오류가 발견되면, 연락을 주시면 감사드립니다. 바로 고치도록 하겠습니다. 6 | 7 | 유재성 (praster1@gmail.com) -------------------------------------------------------------------------------- /9장. 특수 토픽/README.md: -------------------------------------------------------------------------------- 1 | 허명회 선생님의 <수리통계학 강의> 9장 링크는 다음과 같습니다. 2 | 3 | http://www.statground.org/index.php?mid=MyungHoeHuh&document_srl=9024 4 | 5 | 다만 제가 나름대로 공부하며 작성한 것이다보니, 원 저자의 의도와는 다른 오류가 있을 수 있습니다. 혹시 그러한 오류가 발견되면, 연락을 주시면 감사드립니다. 바로 고치도록 하겠습니다. 6 | 7 | 유재성 (praster1@gmail.com) -------------------------------------------------------------------------------- /2장. 기본적인 확률도구 5개/README.md: -------------------------------------------------------------------------------- 1 | 허명회 선생님의 <수리통계학 강의> 2장 링크는 다음과 같습니다. 2 | 3 | http://www.statground.org/index.php?mid=MyungHoeHuh&document_srl=8910 4 | 5 | 다만 제가 나름대로 공부하며 작성한 것이다보니, 원 저자의 의도와는 다른 오류가 있을 수 있습니다. 혹시 그러한 오류가 발견되면, 연락을 주시면 감사드립니다. 바로 고치도록 하겠습니다. 6 | 7 | 유재성 (praster1@gmail.com) -------------------------------------------------------------------------------- /3장. 재미있는 확률문제 5개/README.md: -------------------------------------------------------------------------------- 1 | 허명회 선생님의 <수리통계학 강의> 3장 링크는 다음과 같습니다. 2 | 3 | http://www.statground.org/index.php?mid=MyungHoeHuh&document_srl=8914 4 | 5 | 다만 제가 나름대로 공부하며 작성한 것이다보니, 원 저자의 의도와는 다른 오류가 있을 수 있습니다. 혹시 그러한 오류가 발견되면, 연락을 주시면 감사드립니다. 바로 고치도록 하겠습니다. 6 | 7 | 유재성 (praster1@gmail.com) -------------------------------------------------------------------------------- /4장. 가능도(Likelihood); 개념, 계산, 속성/README.md: -------------------------------------------------------------------------------- 1 | 허명회 선생님의 <수리통계학 강의> 4장 링크는 다음과 같습니다. 2 | 3 | http://www.statground.org/index.php?mid=MyungHoeHuh&document_srl=8937 4 | 5 | 다만 제가 나름대로 공부하며 작성한 것이다보니, 원 저자의 의도와는 다른 오류가 있을 수 있습니다. 혹시 그러한 오류가 발견되면, 연락을 주시면 감사드립니다. 바로 고치도록 하겠습니다. 6 | 7 | 유재성 (praster1@gmail.com) -------------------------------------------------------------------------------- /2장. 기본적인 확률도구 5개/표 6. 이변량정규분포 확률의 몬테칼로 계산/BN.R: -------------------------------------------------------------------------------- 1 | rho = 0.5; 2 | Nrepeat = 10000; 3 | sum = 0; 4 | 5 | for (i in 1:Nrepeat) 6 | { 7 | z1 = rnorm(1); 8 | z2 = rnorm(1); 9 | x1 = z1; 10 | x2 = rho*z1 + sqrt(1-rho*rho)*z2; 11 | success = ifelse( (x1 >= 1) & (x2 >= 1), 1, 0 ) 12 | sum = sum + success; 13 | } 14 | 15 | p = sum/Nrepeat; 16 | p 17 | -------------------------------------------------------------------------------- /2장. 기본적인 확률도구 5개/표 2. 표준정규분포로부터 임의수 발생시키기/normal.R: -------------------------------------------------------------------------------- 1 | Nrepeat = 100; 2 | sum = 0; 3 | for (i in 1:(Nrepeat/2)) 4 | { 5 | R2 = -2*log(1-runif(1)); 6 | theta = runif(1); 7 | x1 = sqrt(R2)*cos(2*pi*theta); 8 | x2 = sqrt(R2)*sin(2*pi*theta); 9 | 10 | print(paste("x1: ", x1, " x2: ", x2, sep="")) 11 | sum = sum+x1+x2 12 | } 13 | 14 | mean = sum / Nrepeat; 15 | mean -------------------------------------------------------------------------------- /2장. 기본적인 확률도구 5개/표 4. 이항분포로부터 임의수 발생시키기/b.R: -------------------------------------------------------------------------------- 1 | n = 10; theta = 0.25 2 | Nrepeat = 100 3 | sum = 0 4 | 5 | for (i in 1:Nrepeat) 6 | { 7 | sum1 = 0; 8 | 9 | for (j in 1:n) 10 | { 11 | success = ifelse(runif(1) < theta, 1, 0) 12 | sum1 = sum1 + success; 13 | } 14 | 15 | x = sum1; 16 | print(paste("x: ", x, sep="")) 17 | sum = sum + x; 18 | } 19 | 20 | mean = sum/Nrepeat; 21 | mean -------------------------------------------------------------------------------- /2장. 기본적인 확률도구 5개/표 5. 포아송 분포로부터 임의수 발생시키기/poisson.R: -------------------------------------------------------------------------------- 1 | Nrepeat = 100; 2 | theta = 2; 3 | sum = 0; 4 | 5 | for (i in 1:Nrepeat) 6 | { 7 | count = -1; 8 | sum1 = 0; 9 | while(sum1 < 1) 10 | { 11 | t = -(1/theta)*log(1-runif(1)); 12 | sum1 = sum1 + t; 13 | count = count + 1 14 | } 15 | N = count; 16 | 17 | print(paste("N: ", N, sep="")) 18 | sum = sum + N; 19 | } 20 | 21 | mean = sum / Nrepeat; 22 | mean -------------------------------------------------------------------------------- /3장. 재미있는 확률문제 5개/표 3. 뷔퐁의 바늘 문제 풀이를 위한 몬테칼로 프로그램/needle.R: -------------------------------------------------------------------------------- 1 | d = 2; 2 | Nrepeat = 10000; 3 | pi0 = 4; 4 | count = 0; 5 | success = 0; 6 | 7 | for (i in 1:Nrepeat) 8 | { 9 | theta = runif(1)*pi0; 10 | y = runif(1)*d/2; 11 | temp = sin(theta); 12 | if (temp >= 0) { count = count + 1; } 13 | if (y <= (0.5*temp)) { success = success + 1; } 14 | } 15 | 16 | p = success/count; 17 | estimate = 2/(d*p); 18 | 19 | p 20 | estimate -------------------------------------------------------------------------------- /2장. 기본적인 확률도구 5개/표 1. 지수분포로부터 임의수 발생시키기/exp.iml: -------------------------------------------------------------------------------- 1 | /* Exponential(2) Random Number Genereation */ 2 | /* exp.iml */ 3 | 4 | proc iml; 5 | Nrepeat = 100; 6 | sum = 0; 7 | do repeat=1 to Nrepeat; 8 | u = uniform(0); 9 | x = -2*log(1-u); 10 | print u x; 11 | sum = sum + x; 12 | end; 13 | mean = sum / Nrepeat; 14 | print Nrepeat mean; 15 | quit; 16 | -------------------------------------------------------------------------------- /2장. 기본적인 확률도구 5개/표 3. 음이항분포로부터 임의수 발생시키기/nb.R: -------------------------------------------------------------------------------- 1 | r = 4; theta = 0.25 2 | Nrepeat = 100 3 | sum = 0 4 | 5 | for (i in 1:Nrepeat) 6 | { 7 | sum1 = 0; sum0 = 0; 8 | 9 | while(sum1 < r) 10 | { 11 | success = ifelse(runif(1) < theta, 1, 0) 12 | sum1 = sum1 + success; 13 | sum0 = sum0 + 1 - success; 14 | } 15 | 16 | x = sum0 17 | print(paste("x: ", x, sep="")) 18 | sum = sum + x; 19 | } 20 | 21 | mean = sum/Nrepeat; 22 | mean -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | R Codes for "허명회 (2001), <수리통계학 강의>" 2 | ================= 3 | 4 | 허명회 선생님의 <수리통계학 강의>의 SAS 코드를 R로 작성하여 보았습니다. 5 | 6 | <수리통계학 강의> 책은 여기에서 확인하실 수 있고요. http://www.statground.org/index.php?mid=MyungHoeHuh 7 | 8 | 원 저자인 허명회 선생님의 허락을 받아 공유를 하게 되었습니다. 9 | 10 | 가급적이면 원래의 SAS/IML 코드와 유사하게 유지해보고자 노력하였고요. 왜냐하면, 가령 지수분포로부터 임의수를 발생시킨다고 하면 R에서는 rexp 함수를 사용하면 되지만, 그렇게 하면 책에서의 설명이 코드에 나타나지 않는 것 같아서요. 11 | 12 | 다만 제가 나름대로 공부하며 작성한 것이다보니, 원 저자의 의도와는 다른 오류가 있을 수 있습니다. 혹시 그러한 오류가 발견되면, 연락을 주시면 감사드립니다. 바로 고치도록 하겠습니다. 13 | 14 | 유재성 (praster1@gmail.com) -------------------------------------------------------------------------------- /2장. 기본적인 확률도구 5개/표 2. 표준정규분포로부터 임의수 발생시키기/normal.iml: -------------------------------------------------------------------------------- 1 | /* Standard Normal Random Number Generation */ 2 | /* normal.iml */ 3 | 4 | proc iml; 5 | Nrepeat = 100; 6 | pi = 3.141592; 7 | sum = 0; 8 | do repeat=1 to Nrepeat/2; 9 | R2 = -2*log(1-uniform(0)); 10 | theta = uniform(0); 11 | x1 = sqrt(R2)*cos(2*pi*theta); 12 | x2 = sqrt(R2)*sin(2*pi*theta); 13 | print x1 x2; 14 | sum = sum+x1+x2; 15 | end; 16 | mean = sum/Nrepeat; 17 | print Nrepeat mean; 18 | quit; 19 | -------------------------------------------------------------------------------- /2장. 기본적인 확률도구 5개/표 4. 이항분포로부터 임의수 발생시키기/b.iml: -------------------------------------------------------------------------------- 1 | /* Binomial Random Number Generation */ 2 | /* b.iml */ 3 | 4 | proc iml; 5 | n = 10; theta=0.25; 6 | Nrepeat = 100; 7 | sum = 0; 8 | do repeat=1 to Nrepeat; 9 | sum1=0; 10 | do j = 1 to n; 11 | if uniform(0) < theta then success=1; 12 | else success=0; 13 | sum1 = sum1 + success; 14 | end; 15 | x = sum1; 16 | print x; 17 | sum = sum + x; 18 | end; 19 | mean = sum/Nrepeat; 20 | print Nrepeat mean; 21 | quit; 22 | -------------------------------------------------------------------------------- /2장. 기본적인 확률도구 5개/표 6. 이변량정규분포 확률의 몬테칼로 계산/BN.iml: -------------------------------------------------------------------------------- 1 | /* Monte-Carlo Computing of Bivariate Normal Probability */ 2 | /* FileName bn.iml */ 3 | 4 | proc iml; 5 | rho = 0.5; 6 | Nrepeat = 10000; 7 | sum = 0; 8 | do repeat=1 to Nrepeat; 9 | z1 = normal(0); 10 | z2 = normal(0); 11 | x1 = z1; 12 | x2 = rho*z1 + sqrt(1-rho*rho)*z2; 13 | if x1 >= 1 & x2 >= 1 then success = 1; 14 | else success = 0; 15 | sum = sum + success; 16 | end; 17 | p = sum/Nrepeat; 18 | print Nrepeat p; 19 | quit; 20 | -------------------------------------------------------------------------------- /5장. 점 추정론/표 1. 심프슨의 1／3 규칙에 의한 수치적분/simpson.R: -------------------------------------------------------------------------------- 1 | a = 0; b = 3; 2 | N = 1000; 3 | 4 | g = function(x1, x2, x3) 5 | { 6 | g1 = x1*630*((1-exp(-x1))**4)*exp(-5*x1); 7 | g2 = x2*630*((1-exp(-x2))**4)*exp(-5*x2); 8 | g3 = x3*630*((1-exp(-x3))**4)*exp(-5*x3); 9 | 10 | result = list(g1 = g1, g2 = g2, g3 = g3) 11 | return(result) 12 | } 13 | 14 | 15 | sum0 = 0; 16 | for (i in 1:N) 17 | { 18 | x1 = (b-a)/N*(i-1); 19 | x3 = (b-a)/N*i; 20 | x2 = (x1+x3)/2; 21 | 22 | g_res = g(x1, x2, x3); 23 | sum0 = sum0 + (b-a)/N*(g_res$g1+4*g_res$g2+g_res$g3)/6; 24 | } 25 | 26 | 27 | sum0 -------------------------------------------------------------------------------- /2장. 기본적인 확률도구 5개/표 5. 포아송 분포로부터 임의수 발생시키기/poisson.iml: -------------------------------------------------------------------------------- 1 | /* Poisson Random Number Generation */ 2 | /* poisson.iml */ 3 | 4 | proc iml; 5 | Nrepeat = 100; 6 | theta = 2; 7 | sum = 0; 8 | do repeat=1 to Nrepeat; 9 | count = -1; 10 | sum1 = 0; 11 | do while (sum1 < 1); 12 | t = -(1/theta)*log(1-uniform(0)); 13 | sum1 = sum1 + t; 14 | count = count + 1; 15 | end; 16 | N = count; 17 | print N; 18 | sum = sum + N; 19 | end; 20 | mean = sum / Nrepeat; 21 | print Nrepeat mean; 22 | quit; 23 | -------------------------------------------------------------------------------- /3장. 재미있는 확률문제 5개/표 2. 쿠폰 수집 문제를 위한 몬테칼로 프로그램/COUPON.R: -------------------------------------------------------------------------------- 1 | n = 365; 2 | Nrepeat = 1000; 3 | Xrecord = rep(0, Nrepeat) 4 | sum1 = 0; 5 | 6 | for (i in 1:Nrepeat) 7 | { 8 | sum0=0; 9 | 10 | for (coupon in 2:n) 11 | { 12 | theta=1-(coupon-1)/n; 13 | success = 0; 14 | 15 | while(success == 0) 16 | { 17 | if (runif(1) < theta) { success=1; } 18 | sum0 = sum0 + 1- success; 19 | } 20 | 21 | x = n + sum0; 22 | Xrecord[i] = x; 23 | } 24 | 25 | sum1 = sum1 + x; 26 | } 27 | 28 | mean0 = sum1/Nrepeat; 29 | mean0 30 | 31 | hist(Xrecord) # <그림 3> 쿠폰 수 분포 (n=365, 몬테칼로 시행결과) : 유재성 -------------------------------------------------------------------------------- /8장. 통계적 모형론/표 3. 독성실험 자료/표 3.R: -------------------------------------------------------------------------------- 1 | ### 원래 SAS 코드가 없습니다. : 유재성 2 | 3 | X = c(1.691, 1.691, 1.724, 1.724, 1.755, 1.755, 1.784, 1.784, 1.811, 1.811, 1.837, 1.837, 1.861, 1.861, 1.884, 1.884) 4 | Y = c(1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0) 5 | count = c(6, 53, 13, 47, 18, 44, 28, 38, 52, 11, 53, 6, 61, 1, 60, 0) 6 | 7 | 8 | 9 | newX = NULL; newY = NULL; 10 | 11 | for (i in 1:16) 12 | { 13 | if (count[i] > 0) 14 | { 15 | for (j in 1:count[i]) 16 | { 17 | newX = c(newX, X[i]); newY = c(newY, Y[i]); 18 | } 19 | } 20 | } 21 | 22 | model = glm(newY ~ newX, family = "binomial") 23 | summary(model) -------------------------------------------------------------------------------- /3장. 재미있는 확률문제 5개/표 3. 뷔퐁의 바늘 문제 풀이를 위한 몬테칼로 프로그램/needle.iml: -------------------------------------------------------------------------------- 1 | /* Buffon's Needle Simulation */ 2 | /* needle.iml */ 3 | 4 | proc iml; 5 | d = 2; 6 | Nrepeat = 10000; 7 | pi = 4; 8 | count = 0; 9 | success = 0; 10 | do repeat=1 to Nrepeat; 11 | theta = uniform(0)*pi; 12 | y = uniform(0)*d/2; 13 | temp = sin(theta); 14 | if temp >= 0 then count = count + 1; 15 | if y <= 0.5*temp then success = success + 1; 16 | end; 17 | p = success/count; 18 | estimate = 2/(d*p); 19 | print Nrepeat count success p[format=12.4] estimate[format=12.4]; 20 | end; 21 | -------------------------------------------------------------------------------- /2장. 기본적인 확률도구 5개/표 3. 음이항분포로부터 임의수 발생시키기/nb.iml: -------------------------------------------------------------------------------- 1 | /* Negative Binomial Random Number Generation */ 2 | /* nb.iml */ 3 | 4 | proc iml; 5 | r = 4; theta=0.25; 6 | Nrepeat = 100; 7 | sum = 0; 8 | do repeat=1 to Nrepeat; 9 | sum1=0; sum0=0; 10 | do while (sum1 < r); 11 | if uniform(0) < theta then success=1; 12 | else success=0; 13 | sum1 = sum1 + success; 14 | sum0 = sum0 + 1- success; 15 | end; 16 | x = sum0; 17 | print x; 18 | sum = sum + x; 19 | end; 20 | mean = sum/Nrepeat; 21 | print Nrepeat mean; 22 | quit; 23 | -------------------------------------------------------------------------------- /7장. 구간 추정론/표 1. 이항표본에서 신뢰구간의 상한을 구하기 위한 프로그램/conf1.R: -------------------------------------------------------------------------------- 1 | theta0=0; theta1=1; diff=1; n = 100; s = 57; iter = 1; 2 | while(diff > 0.0001) 3 | { 4 | theta = (theta0+theta1)/2; 5 | temp1 = 1; temp2 = (1-theta)^n; 6 | cumprob = temp2; 7 | for (k in 1:s) 8 | { 9 | temp1 = temp1*(n-k+1)/k*theta/(1-theta); 10 | prob = temp1*temp2; 11 | cumprob = cumprob + prob; 12 | } 13 | diff = abs(cumprob-0.025); 14 | 15 | if (cumprob < 0.025) { print(paste("iter = ", iter, " cumprob = ", cumprob, " theta = ", theta, sep="")) } 16 | 17 | if (cumprob > 0.025) { theta0 = theta; } 18 | else { theta1 = theta; } 19 | 20 | iter = iter + 1; 21 | } -------------------------------------------------------------------------------- /5장. 점 추정론/표 1. 심프슨의 1／3 규칙에 의한 수치적분/simpson.iml: -------------------------------------------------------------------------------- 1 | /* Numerical Integration by Simpson's 1/3 Rule */ 2 | /* simpson.iml */ 3 | 4 | proc iml; 5 | a = 0; b = 3; 6 | N = 1000; 7 | 8 | start g; 9 | g1 = x1*630*((1-exp(-x1))**4)*exp(-5*x1); 10 | g2 = x2*630*((1-exp(-x2))**4)*exp(-5*x2); 11 | g3 = x3*630*((1-exp(-x3))**4)*exp(-5*x3); 12 | finish; 13 | 14 | sum = 0; 15 | do i=1 to N; 16 | x1 = (b-a)/N*(i-1); 17 | x3 = (b-a)/N*i; 18 | x2 = (x1+x3)/2; 19 | run g; 20 | sum = sum + (b-a)/N*(g1+4*g2+g3)/6; 21 | end; 22 | print sum[format=10.4]; 23 | quit; 24 | -------------------------------------------------------------------------------- /3장. 재미있는 확률문제 5개/표 1. 도박꾼의 파산 문제를 위한 몬테칼로 프로그램/RUIN.R: -------------------------------------------------------------------------------- 1 | p = 18/38; q = 1-p; 2 | k = 5; n = 10 ; 3 | Nrepeat=1000; 4 | S = rep(0, Nrepeat) # Value 1 = Ruin, Value 0 = Success 5 | T = rep(0, Nrepeat) # Real Value := Game Duration Time 6 | 7 | for (i in 1:Nrepeat) 8 | { 9 | position = k; 10 | time = 0; 11 | 12 | while((position > 0) & (position < n)) 13 | { 14 | position = ifelse(runif(1)< p, position+1, position-1) 15 | time = time + 1; 16 | } 17 | 18 | if (position == 0) { S[i] = 1; } 19 | T[i] = time; 20 | } 21 | 22 | mean1 = sum(S)/Nrepeat 23 | mean2 = sum(T)/Nrepeat 24 | 25 | mean1 26 | mean2 27 | 28 | 29 | hist(T) # <그림 2> 게임 수 분포 (몬테칼로 시행결과) : 유재성 -------------------------------------------------------------------------------- /7장. 구간 추정론/표 3. 근사적 신뢰구간의 포함확률 평가를 위한 프로그램/conf3.R: -------------------------------------------------------------------------------- 1 | n = 4; theta = 2; 2 | Nrepeat = 10000; 3 | Ncover=0; 4 | for (i in 1:Nrepeat) 5 | { 6 | sum = 0; 7 | for (j in 1:n) 8 | { 9 | count = -1; 10 | sum1 = 0; 11 | while(sum1 < 1) 12 | { 13 | t = -(1/theta)*log(1-runif(1)); 14 | sum1 = sum1 + t; 15 | count = count + 1; 16 | } 17 | X = count; 18 | sum = sum + X; 19 | } 20 | 21 | Xbar = sum / n; 22 | U = Xbar + 1.96*sqrt(Xbar/n); 23 | L = Xbar - 1.96*sqrt(Xbar/n); 24 | cover=0; 25 | 26 | if (theta <= U) 27 | { 28 | if (theta >= L) 29 | { 30 | cover=1; 31 | } 32 | } 33 | Ncover = Ncover + cover; 34 | } 35 | 36 | coverage = Ncover / Nrepeat; 37 | 38 | theta 39 | Nrepeat 40 | coverage 41 | 42 | -------------------------------------------------------------------------------- /4장. 가능도(Likelihood); 개념, 계산, 속성/표 2. 뉴튼-라프슨 방법으로 최대가능도 추정값 구하기/mle.R: -------------------------------------------------------------------------------- 1 | theta = 4; # user-supplied initial value 2 | maxtol = 0.0001; maxiter = 10000; 3 | 4 | ell = function(theta) 5 | { 6 | lik = 22*log(theta) - 4*theta; # user-supplied log-likelihood 7 | lik1 = 22/theta - 4; # user-supplied first derivative 8 | lik2 = -22/(theta*theta); # user-supplied second derivative 9 | 10 | result = list(lik = lik, lik1 = lik1, lik2 = lik2) 11 | return(result); 12 | } 13 | 14 | iter = 0; 15 | tol = 1; 16 | while ((iter <= maxiter) && (tol > maxtol)) 17 | { 18 | theta1 = theta - ell(theta)$lik1/ell(theta)$lik2; 19 | tol = abs(theta1 - theta); 20 | theta = theta1; 21 | iter = iter + 1; 22 | } 23 | 24 | iter 25 | theta 26 | ell(theta)$lik1 27 | ell(theta)$lik2 -------------------------------------------------------------------------------- /3장. 재미있는 확률문제 5개/표 2. 쿠폰 수집 문제를 위한 몬테칼로 프로그램/COUPON.IML: -------------------------------------------------------------------------------- 1 | /* Coupon Collection - How many coupons do we need to buy? */ 2 | /* coupon.iml */ 3 | 4 | proc iml; 5 | n = 365; 6 | Nrepeat = 1000; 7 | Xrecord = j(Nrepeat,1,0); 8 | sum = 0; 9 | do repeat=1 to Nrepeat; 10 | sum0=0; 11 | do coupon=2 to n; 12 | theta=1-(coupon-1)/n; 13 | success = 0; 14 | do while (success = 0); 15 | if uniform(0) < theta then success=1; 16 | sum0 = sum0 + 1- success; 17 | end; 18 | x = n + sum0; 19 | Xrecord[repeat] = x; 20 | end; 21 | sum = sum + x; 22 | end; 23 | mean = sum/Nrepeat; 24 | print Nrepeat n mean; 25 | print Xrecord; 26 | quit; 27 | -------------------------------------------------------------------------------- /7장. 구간 추정론/표 1. 이항표본에서 신뢰구간의 상한을 구하기 위한 프로그램/conf1.iml: -------------------------------------------------------------------------------- 1 | /* Upper Confidence Limit for Binomial Case with n = 100 and s = 57 */ 2 | /* File Name: conf1.iml */ 3 | 4 | proc iml; 5 | theta0=0; theta1=1; diff=1; n = 100; s = 57; iter = 1; 6 | do while (diff > 0.0001); 7 | theta=(theta0+theta1)/2; 8 | temp1 = 1; temp2 = (1-theta)**n; 9 | cumprob = temp2; 10 | do k=1 to s; 11 | temp1 = temp1*(n-k+1)/k*theta/(1-theta); 12 | prob = temp1*temp2; 13 | cumprob = cumprob + prob; 14 | end; 15 | diff = abs(cumprob-0.025); 16 | if cumprob < 0.025 then print iter cumprob[format=8.4] theta[format=8.4]; 17 | if cumprob > 0.025 then theta0 = theta; 18 | else theta1=theta; 19 | iter = iter + 1; 20 | end; 21 | quit; 22 | -------------------------------------------------------------------------------- /8장. 통계적 모형론/표 1. Q의 상위 5% 분위수 계산을 위한 프로그램/tukey.R: -------------------------------------------------------------------------------- 1 | II = 4; n = 5; Nrepeat = 99999; 2 | Y = matrix(0, II,n); 3 | PairDiff = matrix(0,II,II); 4 | Q = rep(0, Nrepeat); Qsort = rep(0, Nrepeat); 5 | 6 | for (i in 1:Nrepeat) 7 | { 8 | for (j in 1:II) 9 | { 10 | for (k in 1:n) 11 | { 12 | Y[j,k] = rnorm(1); 13 | } 14 | } 15 | 16 | Ybar = apply(Y, 1, sum)/n 17 | Residual = Y - Ybar%*%matrix(1, 1, n); 18 | s = sqrt(sum(Residual^2)/(II*n-II)); 19 | 20 | for (j in 1:II) 21 | { 22 | for (k in 1:II) 23 | { 24 | PairDiff[j,k] = abs(Ybar[j] - Ybar[k]); 25 | } 26 | } 27 | 28 | Q[i] = max(PairDiff)/s*sqrt(n); 29 | } 30 | 31 | R = rank(Q, ties.method="random"); 32 | for (i in 1:Nrepeat) 33 | { 34 | Qsort[R[i]] = Q[i]; 35 | } 36 | Q05 = Qsort[(Nrepeat+1)*0.95]; 37 | 38 | Nrepeat 39 | Q05 40 | 41 | hist(Q) # 반복 수 : Nrepeat -------------------------------------------------------------------------------- /3장. 재미있는 확률문제 5개/표 4. Let's Make a Deal 문제 풀이를 위한 몬테칼로 프로그램/lmad.R: -------------------------------------------------------------------------------- 1 | rule = 1; 2 | Nrepeat = 1000; 3 | sum0 = 0; 4 | 5 | 6 | for (i in 1:Nrepeat) 7 | { 8 | t1 = runif(1); 9 | if (t1 <= 1/3) {u = 1} 10 | else if (t1 <= 2/3) {u = 2} 11 | else {u = 3;} 12 | 13 | t2 = runif(1); 14 | if (t2 <= 1/3) {x = 1} 15 | else if (t2 <= 2/3) {x = 2} 16 | else {x = 3;} 17 | 18 | 19 | if (x != u) 20 | { 21 | v = ( x%/%3 ) + 1; 22 | if (v == u) { v = ( u%/%3 ) + 1; } 23 | } 24 | 25 | if (x == u) 26 | { 27 | t3 = runif(1); 28 | v = ifelse( t3 <= 1/2 , (( u%/%3 ) + 1) , ( ( (u+1)%/%3 ) + 1) ); 29 | } 30 | 31 | if (rule==0) { y = x } 32 | if (rule==1) 33 | { 34 | y = ( x%/%3 )+1; 35 | if (y == v) { y = ( v%/%3 )+1 } 36 | } 37 | 38 | success = ifelse(u == y, 1, 0) 39 | sum0 = sum0 + success; 40 | } 41 | 42 | p = sum0 / Nrepeat; 43 | p 44 | -------------------------------------------------------------------------------- /3장. 재미있는 확률문제 5개/표 1. 도박꾼의 파산 문제를 위한 몬테칼로 프로그램/RUIN.IML: -------------------------------------------------------------------------------- 1 | /* Game Duration Time for Gambler's Ruin Problem */ 2 | /* ruin.iml */ 3 | 4 | proc iml; 5 | p = 18/38; q = 1-p; 6 | k = 5; n = 10 ; 7 | Nrepeat=1000; 8 | S = j(Nrepeat,1,0); /* Value 1 = Ruin, Value 0 = Success */ 9 | T = j(Nrepeat,1,0); /* Real Value := Game Duration Time */ 10 | 11 | do repeat=1 to Nrepeat; 12 | position = k; 13 | time = 0; 14 | do while ((position > 0) & (position < n)); 15 | if uniform(0) < p then position = position+1; 16 | else position = position-1; 17 | time = time + 1; 18 | end; 19 | if position = 0 then S[repeat] = 1; 20 | T[repeat] = time; 21 | end; 22 | mean1 = S[+]/Nrepeat; 23 | mean2 = T[+]/Nrepeat; 24 | print Nrepeat mean1 mean2; 25 | print S T; 26 | quit; 27 | -------------------------------------------------------------------------------- /8장. 통계적 모형론/표 1. Q의 상위 5% 분위수 계산을 위한 프로그램/tukey.iml: -------------------------------------------------------------------------------- 1 | /* Tukey's Multiple Comparison */ 2 | /* tukey.iml */ 3 | 4 | proc iml; 5 | II = 4; n = 5; Nrepeat = 99999; 6 | Y = j(II,n,0); 7 | PairDiff = j(II,II,0); 8 | Q = j(Nrepeat,1,0); Qsort = j(Nrepeat,1,0); 9 | 10 | do repeat = 1 to Nrepeat; 11 | do i =1 to II; do j = 1 to n; 12 | Y[i,j] = rannor(0); 13 | end; end; 14 | Ybar = Y[,+]/n; 15 | Residual = Y - Ybar*j(1,n,1); 16 | s = sqrt(ssq(Residual)/(II*n-II)); 17 | do i = 1 to II; do j = 1 to II; 18 | PairDiff[i,j] = abs(Ybar[i] - Ybar[j]); 19 | end; end; 20 | Q[repeat] = max(PairDiff)/s*sqrt(n); 21 | end; 22 | 23 | R = rank(Q); 24 | do repeat = 1 to Nrepeat; 25 | Qsort[R[repeat]] = Q[repeat]; 26 | end; 27 | Q05 = Qsort[(Nrepeat+1)*0.95]; 28 | print Nrepeat Q05[format=8.3]; 29 | quit; 30 | -------------------------------------------------------------------------------- /7장. 구간 추정론/표 3. 근사적 신뢰구간의 포함확률 평가를 위한 프로그램/conf3.iml: -------------------------------------------------------------------------------- 1 | /* Coverage Evaluation for Poisson Parameter */ 2 | /* File Name: conf3.iml */ 3 | 4 | proc iml; 5 | n = 4; theta = 2; 6 | Nrepeat = 10000; 7 | Ncover=0; 8 | do repeat=1 to Nrepeat; 9 | sum = 0; 10 | do sample=1 to n; 11 | count = -1; 12 | sum1 = 0; 13 | do while (sum1 < 1); 14 | t = -(1/theta)*log(1-uniform(0)); 15 | sum1 = sum1 + t; 16 | count = count + 1; 17 | end; 18 | X = count; 19 | sum = sum + X; 20 | end; 21 | Xbar = sum / n; 22 | U = Xbar + 1.96*sqrt(Xbar/n); 23 | L = Xbar - 1.96*sqrt(Xbar/n); 24 | cover=0; 25 | if theta <= U then do; if theta >= L then cover=1; end; 26 | Ncover = Ncover + cover; 27 | end; 28 | coverage = Ncover / Nrepeat; 29 | print theta Nrepeat coverage; 30 | 31 | quit; 32 | -------------------------------------------------------------------------------- /4장. 가능도(Likelihood); 개념, 계산, 속성/표 2. 뉴튼-라프슨 방법으로 최대가능도 추정값 구하기/mle.iml: -------------------------------------------------------------------------------- 1 | /* Newton-Raphson method for MLE computing */ 2 | /* mle.iml */ 3 | 4 | proc iml; 5 | theta = 4; /* user-supplied initial value */ 6 | maxtol = 0.0001; maxiter = 10000; 7 | 8 | start ell; 9 | lik = 22*log(theta) - 4*theta; /* user-supplied log-likelihood */ 10 | lik1 = 22/theta - 4; /* user-supplied first derivative */ 11 | lik2 = -22/(theta*theta); /* user-supplied second derivative */ 12 | finish; 13 | 14 | iter = 0; 15 | tol = 1; 16 | do while (iter <= maxiter & tol > maxtol); 17 | 18 | run ell; 19 | theta1 = theta - lik1/lik2; 20 | tol = abs(theta1 - theta); 21 | theta = theta1; 22 | iter = iter + 1; 23 | end; 24 | 25 | print iter theta[format=12.4] lik1[format=12.4] lik[format=12.4]; 26 | quit; 27 | -------------------------------------------------------------------------------- /9장. 특수 토픽/표 3. 상관계수 r의 임의순열 분포를 구하기 위한 프로그램/permute.R: -------------------------------------------------------------------------------- 1 | Nrepeat = 1000; 2 | x = c(15, 26, 10, 9, 15, 20, 18, 11, 8, 20, 7, 9, 10, 11, 11, 10, 12, 17, 11, 10) 3 | y = c(95, 71, 83, 91, 102, 87, 93, 100, 104, 94, 113, 96, 83, 84, 102, 100, 105, 121, 86, 100) 4 | n = length(x); 5 | r = rep(0, Nrepeat) 6 | 7 | xbar = sum(x)/n; ybar = sum(y)/n; 8 | num = sum(x*y) - n*xbar*ybar; 9 | denum = sqrt((sum(x^2)-n*xbar*xbar)*(sum(y^2)-n*ybar*ybar)); 10 | r0 = num/denum; 11 | 12 | n 13 | r0 14 | 15 | u = rep(0, n); 16 | count = 0; 17 | for (i in 1:Nrepeat) 18 | { 19 | for (j in 1:n) { u[j] = runif(1); } 20 | rnk = rank(u, ties.method="random"); y1 = y; 21 | for (j in 1:n) { y1[rnk[j]] = y[j]; } 22 | y1bar = sum(y1)/n; 23 | num = sum(x*y1) - n*xbar*y1bar; 24 | denum = sqrt((sum(x^2)-n*xbar*xbar)*(sum(y1^2)-n*y1bar*y1bar)); 25 | r1 = num/denum; 26 | if (r1 <= r0) { count=count+1; } 27 | r[i] = r1; 28 | } 29 | 30 | pvalue = count/Nrepeat; 31 | hist(r) 32 | Nrepeat 33 | pvalue 34 | -------------------------------------------------------------------------------- /7장. 구간 추정론/표 4. 특수 정규표본에서 신뢰구간을 구하기 위한 프로그램/conf4.iml: -------------------------------------------------------------------------------- 1 | /* Confidence interval from a special normal sample */ 2 | /* conf4.iml */ 3 | 4 | proc iml; 5 | x = {116.7 94.7 87.8 110.4 93.5}; 6 | s1 = sum(x); s2 = ssq(x); n = ncol(x); 7 | mean = s1/n; sd = sqrt((s2 - s1*s1/n)/(n-1)); 8 | print n mean[format=8.2] sd[format=8.2]; 9 | theta = 90; 10 | maxtol = 0.0001; maxiter = 10000; 11 | 12 | start ell; 13 | lik = -s2/(2*0.01*theta**2)+s1/(0.01*theta)-n*log(theta); 14 | lik1 = s2/(0.01*theta**3)-s1/(0.01*theta**2)-n/theta; 15 | lik2 = -3*s2/(0.01*theta**4)+2*s1/(0.01*theta**3)+n/(theta**2); 16 | finish; 17 | 18 | iter = 0; 19 | tol = 1; 20 | do while (iter <= maxiter & tol > maxtol); 21 | 22 | run ell; 23 | theta1 = theta - lik1/lik2; 24 | tol = abs(theta1 - theta); 25 | theta = theta1; 26 | iter = iter + 1; 27 | end; 28 | 29 | print iter theta[format=12.2] lik2[format=12.4] lik[format=12.4]; 30 | quit; 31 | -------------------------------------------------------------------------------- /7장. 구간 추정론/표 4. 특수 정규표본에서 신뢰구간을 구하기 위한 프로그램/conf4.R: -------------------------------------------------------------------------------- 1 | x = c(116.7, 94.7, 87.8, 110.4, 93.5); 2 | s1 = sum(x); s2 = sum(x^2); n = length(x); 3 | mean0 = s1/n; sd0 = sqrt((s2 - s1*s1/n)/(n-1)); 4 | 5 | n 6 | mean0 7 | sd0 8 | 9 | 10 | 11 | theta = 90; 12 | maxtol = 0.0001; maxiter = 10000; 13 | 14 | ell = function(theta0, n0, s10, s20) 15 | { 16 | lik = -s20/(2*0.01*(theta0**2))+s10/(0.01*theta0)-n0*log(theta0); 17 | lik1 = s20/(0.01*(theta0**3)) - s10/(0.01*(theta0**2)) - n0/theta0; 18 | lik2 = -3*s20/(0.01*(theta0**4))+2*s10/(0.01*(theta0**3))+n0/(theta0**2); 19 | 20 | result = list(lik = lik, lik1 = lik1, lik2 = lik2) 21 | return(result) 22 | } 23 | 24 | 25 | iter = 0; 26 | tol = 1; 27 | 28 | while((iter <= maxiter) && (tol > maxtol)) 29 | { 30 | ell_res = ell(theta, n, s1, s2) 31 | theta1 = theta - ell_res$lik1/ell_res$lik2; 32 | print(theta1) 33 | print(tol) 34 | tol = abs(theta1 - theta); 35 | theta = theta1; 36 | iter = iter + 1; 37 | } 38 | 39 | 40 | iter 41 | theta 42 | ell_res$lik2 43 | ell_res$lik 44 | -------------------------------------------------------------------------------- /4장. 가능도(Likelihood); 개념, 계산, 속성/표 1. 이분법으로 1／k 규칙에 의한 구간 구하기/bike.R: -------------------------------------------------------------------------------- 1 | k = 7; 2 | maxtol = 0.0001; maxiter = 10000; 3 | 4 | theta1 = 3; theta2 = 5; # user-supplied initial values 5 | maxl = 22*log(5.5) - 4*5.5; # user-supplied max log-likelihood 6 | 7 | 8 | ell = function(theta, maxl, k) 9 | { 10 | l = 22*log(theta) - 4*theta; # user-supplied log-likelihood 11 | g = l - maxl + log(k); 12 | result = list(l = l, g = g); 13 | return(result); 14 | } 15 | 16 | iter = 0; 17 | theta = theta1; g1 = ell(theta, maxl, k)$g; 18 | theta = theta2; g2 = ell(theta, maxl, k)$g; 19 | 20 | if (g1*g2 > 0) { print("Initial values are improper!!!"); } 21 | tol = theta2 - theta1; 22 | 23 | while ((iter <= maxiter) && (tol > maxtol)) 24 | { 25 | theta = (theta1 + theta2)/2; 26 | if (g1*ell(theta, maxl, k)$g < 0) { theta2 = theta; g2 = ell(theta, maxl, k)$g; } 27 | else { theta1 = theta; g1 = ell(theta, maxl, k)$g; } 28 | iter = iter + 1; 29 | tol = theta2 - theta1; 30 | } 31 | 32 | 33 | theta = (theta1 + theta2)/2; 34 | 35 | iter 36 | theta1 37 | theta2 38 | theta -------------------------------------------------------------------------------- /8장. 통계적 모형론/표 4. 독성실험 자료의 로짓 모형 분석을 위한 프로그램/logit.R: -------------------------------------------------------------------------------- 1 | X = cbind( rep(1, 16), 2 | c(1.691, 1.691, 1.724, 1.724, 1.755, 1.755, 1.784, 1.784, 1.811, 1.811, 1.837, 1.837, 1.861, 1.861, 1.884, 1.884) ) 3 | y = c(1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0) 4 | count = c(6, 53, 13, 47, 18, 44, 28, 38, 52, 11, 53, 6, 61, 1, 60, 0) 5 | 6 | 7 | beta_old = c(0, 0); tol = 1; repeat0=1; 8 | 9 | while (tol > 0.000001) 10 | { 11 | eta = X %*% beta_old; 12 | bprime1 = exp(eta)/(1+exp(eta)); 13 | bprime2 = bprime1/(1+exp(eta)); 14 | I = t(X)%*%diag(c(count*bprime2))%*%X; 15 | Iinverse = solve(I); 16 | U = t(X)%*%diag(c(count))%*%(y-bprime1); 17 | beta_new = beta_old + Iinverse%*%t(X)%*%diag(c(count))%*%(y-bprime1); 18 | diff0 = beta_new - beta_old; 19 | tol = sum(diff0^2); 20 | print(paste("repeat = ", repeat0, " beta_new = ", beta_new, sep="")) 21 | repeat0 = repeat0+1; 22 | beta_old = beta_new; 23 | } 24 | 25 | loglik = 2*(t(eta)%*%diag(c(count))%*%y - t(count)%*%log(1+exp(eta))); 26 | se = sqrt(diag(Iinverse)); 27 | 28 | loglik 29 | beta_new 30 | se 31 | -------------------------------------------------------------------------------- /9장. 특수 토픽/표 3. 상관계수 r의 임의순열 분포를 구하기 위한 프로그램/permute.iml: -------------------------------------------------------------------------------- 1 | /* Random Permutation Test */ 2 | /* FileName : permute.iml */ 3 | 4 | proc iml; 5 | Nrepeat = 1000; 6 | x = {15 26 10 9 15 20 18 11 8 20 7 9 10 11 11 10 12 17 11 10}; 7 | y = {95 71 83 91 102 87 93 100 104 94 113 96 83 84 102 100 105 121 86 100}; 8 | n = ncol(x); 9 | r = j(Nrepeat,1,0); 10 | 11 | xbar = sum(x)/n; ybar = sum(y)/n; 12 | num = sum(x#y) - n*xbar*ybar; 13 | denum = sqrt((ssq(x)-n*xbar*xbar)*(ssq(y)-n*ybar*ybar)); 14 | r0 = num/denum; 15 | print n r0[format=8.2]; 16 | 17 | u = j(1,n,0); 18 | count = 0; 19 | do repeat=1 to Nrepeat; 20 | do i=1 to n; u[i] = ranuni(0); end; 21 | rnk = rank(u); y1 = y; 22 | do i=1 to n; y1[rnk[i]] = y[i]; end; 23 | y1bar = sum(y1)/n; 24 | num = sum(x#y1) - n*xbar*y1bar; 25 | denum = sqrt((ssq(x)-n*xbar*xbar)*(ssq(y1)-n*y1bar*y1bar)); 26 | r1 = num/denum; 27 | if r1 <= r0 then count=count+1; 28 | r[repeat,1] = r1; 29 | end; 30 | pvalue = count/Nrepeat; 31 | print r[format=8.2]; 32 | print Nrepeat pvalue; 33 | quit; 34 | -------------------------------------------------------------------------------- /6장. 가설 검증론/표 1. 대표본 검증통계량의 몬테칼로 p-값 계산/glrt.R: -------------------------------------------------------------------------------- 1 | Nrepeat = 1000; 2 | E = c(90,30,30,10); 3 | n = sum(E); 4 | count0=0; count1=0; count2=0; count3=0; 5 | for (i in 1:Nrepeat) 6 | { 7 | F = rep(0, 4); 8 | 9 | for (j in 1:n) 10 | { 11 | temp = runif(1); 12 | if (temp <= (9/16)) { F[1]=F[1]+1; } 13 | else if (temp <= (12/16)) { F[2]=F[2]+1; } 14 | else if (temp <= (15/16)) { F[3]=F[3]+1; } 15 | else { F[4]=F[4]+1; } 16 | } 17 | 18 | 19 | if (min(F) != 0) 20 | { 21 | count0 = count0 +1; 22 | G = 2*sum(F*log(F/E)); 23 | W = sum((F-E)*(F-E)/F); 24 | S = sum((F-E)*(F-E)/E); 25 | if (G >= 9.30) { count1=count1+1; } 26 | if (W >= 9.52) { count2=count2+1; } 27 | if (S >= 9.44) { count3=count3+1; } 28 | } 29 | } 30 | 31 | pvalue1 = count1/count0; 32 | pvalue2 = count2/count0; 33 | pvalue3 = count3/count0; 34 | 35 | 36 | pvalue1a = 1-pchisq(9.30, 3) 37 | pvalue2a = 1-pchisq(9.52, 3) 38 | pvalue3a = 1-pchisq(9.44, 3) 39 | 40 | 41 | count0 42 | Nrepeat 43 | 44 | # Monte-Carlo 45 | pvalue1 46 | pvalue2 47 | pvalue3 48 | 49 | #Large-Sample 50 | pvalue1a 51 | pvalue2a 52 | pvalue3a 53 | -------------------------------------------------------------------------------- /9장. 특수 토픽/표 1. 후버의 M-추정치를 구하기 위한 프로그램/robust.R: -------------------------------------------------------------------------------- 1 | x = c(20, 25, 25, 27, 28, 31, 33, 34, 36, 37, 44, 50, 59, 85, 86) 2 | n = length(x); 3 | mean0 = sum(x)/n; sd0 = sqrt((sum(x^2)-n*mean0*mean0)/(n-1)); 4 | 5 | y = rep(0, n); r = rank(x, ties.method="random"); 6 | for (i in 1:n) { y[r[i]] = x[i]; } 7 | median0 = ifelse( (n%/%2) != 0 , y[(n+1)/2], (y[n/2] + y[n/2+1])/2 ) 8 | 9 | x1 = abs(x - median0*rep(1,n)); 10 | r1 = rank(x1, ties.method="random"); 11 | for (i in 1:n) { y[r1[i]] = x1[i]; } 12 | mad0 = ifelse( (n%/%2) != 0 , y[(n+1)/2]/0.6745, (y[n/2] + y[n/2+1])/2/0.6745 ) 13 | 14 | n 15 | mean0 16 | sd0 17 | median0 18 | mad0 19 | 20 | k = 1.5; theta0 = median0; iter=0; diff0=1; 21 | while (diff0 > 0.0001) 22 | { 23 | temp = (x-theta0*rep(1,n))/mad0; 24 | num = temp; denum = rep(1,n); 25 | for (i in 1:n) 26 | { 27 | if( temp[i] > k ) { num[i] = k; } 28 | else if (temp[i] < -k ) { num[i] = -k; } 29 | 30 | if (abs(temp[i]) > k) { denum[i] = 0; } 31 | } 32 | 33 | theta = theta0 + mad0*sum(num)/sum(denum); 34 | diff0 = abs(theta-theta0); 35 | iter = iter + 1; 36 | theta0 = theta; 37 | } 38 | se = mad0*sqrt(sum(num*num)/(sum(denum)*sum(denum))); 39 | 40 | 41 | iter 42 | theta 43 | se -------------------------------------------------------------------------------- /4장. 가능도(Likelihood); 개념, 계산, 속성/표 1. 이분법으로 1／k 규칙에 의한 구간 구하기/bike.iml: -------------------------------------------------------------------------------- 1 | /* Bisection method for 1/k rule interval computing */ 2 | /* bike.iml */ 3 | 4 | proc iml; 5 | k = 7; 6 | maxtol = 0.0001; maxiter = 10000; 7 | 8 | theta1 = 3; theta2 = 5; /* user-supplied initial values */ 9 | maxl = 22*log(5.5) - 4*5.5; /* user-supplied max log-likelihood */ 10 | start ell; 11 | l = 22*log(theta) - 4*theta; /* user-supplied log-likelihood */ 12 | g = l - maxl + log(k); 13 | finish; 14 | 15 | iter = 0; 16 | theta = theta1; run ell; g1 = g; 17 | theta = theta2; run ell; g2 = g; 18 | if (g1*g2 > 0) then print "Initial values are improper!!!"; 19 | tol = theta2 - theta1; 20 | 21 | do while (iter <= maxiter & tol > maxtol); 22 | theta = (theta1 + theta2)/2; 23 | run ell; 24 | if (g1*g < 0) then do; theta2 = theta; g2 = g; end; 25 | else do; theta1 = theta; g1 = g; end; 26 | iter = iter + 1; 27 | tol = theta2 - theta1; 28 | end; 29 | 30 | theta = (theta1 + theta2)/2; 31 | print iter theta1[format=12.4] theta2[format=12.4] theta[format=12.4]; 32 | quit; 33 | -------------------------------------------------------------------------------- /3장. 재미있는 확률문제 5개/표 4. Let's Make a Deal 문제 풀이를 위한 몬테칼로 프로그램/lmad.iml: -------------------------------------------------------------------------------- 1 | /* Let's Make a Deal */ 2 | /* rule=1 for "change rule", rule = 0 for "no change rule" */ 3 | /* lmad.iml */ 4 | 5 | 6 | proc iml; 7 | rule = 1; 8 | Nrepeat = 1000; 9 | sum = 0; 10 | do repeat=1 to Nrepeat; 11 | t1 = uniform(0); 12 | if t1 <= 1/3 then u = 1; 13 | else if t1 <= 2/3 then u = 2; 14 | else u = 3; 15 | t2 = uniform(0); 16 | if t2 <= 1/3 then x = 1; 17 | else if t2 <= 2/3 then x = 2; 18 | else x = 3; 19 | if x ^= u then do; 20 | v = mod(x,3)+1; 21 | if v = u then v = mod(u,3)+1; 22 | end; 23 | if x = u then do; 24 | t3 = uniform(0); 25 | if t3 <= 1/2 then v = mod(u,3)+1; 26 | else v = mod(u+1,3)+1; 27 | end; 28 | if rule=0 then y = x; 29 | if rule=1 then do; 30 | y = mod(x,3)+1; 31 | if y = v then y = mod(v,3)+1; 32 | end; 33 | if u = y then success = 1; else success = 0; 34 | sum = sum + success; 35 | /* print u x v y success; */ 36 | end; 37 | p = sum / Nrepeat; 38 | print rule Nrepeat sum p; 39 | quit; 40 | -------------------------------------------------------------------------------- /5장. 점 추정론/표 2. 오염정규분포에서 두 통게량 T1과 T2의 비교/contam2.R: -------------------------------------------------------------------------------- 1 | theta = 10; sigma = 1; n = 40; n1 = n*0.9; 2 | Nrepeat = 1000; 3 | 4 | stats = function(x, n) # Computing Median and Mean 5 | { 6 | r = rank(x, ties.method="random"); x1 = rep(0, n); 7 | 8 | for (i in 1:n) 9 | { 10 | x1[r[i]] = x[i]; 11 | } 12 | 13 | if (n %/%2 == 0) { median0 = (x1[n/2] + x1[n/2+1])/2; } 14 | else { median0 = x1[(n+1)/2]; } 15 | 16 | mean0 = sum(x)/n; 17 | 18 | result = list(mean0 = mean0, median0 = median0) 19 | return(result) 20 | } 21 | 22 | 23 | for (k in 1:5) 24 | { 25 | x = rep(0, n); M1 = rep(0, Nrepeat); M2 = rep(0, Nrepeat); 26 | 27 | # Monte-Carlo Generation of Contaminated Samples 28 | for (m in 1:Nrepeat) 29 | { 30 | for (i in 1:n) 31 | { 32 | x[i] = theta + sigma*rnorm(1); 33 | } 34 | 35 | for (i in (n1+1):n) 36 | { 37 | x[i] = theta + k*sigma*rnorm(1); 38 | } 39 | 40 | M1[m] = stats(x, n)$mean0; M2[m] = stats(x, n)$median0; 41 | } 42 | 43 | 44 | mean1 = sum(M1)/Nrepeat; 45 | var1 = (sum(M1^2) - Nrepeat*mean1*mean1)/(Nrepeat-1); 46 | mean2 = sum(M2)/Nrepeat; 47 | var2 = (sum(M2^2) - Nrepeat*mean2*mean2)/(Nrepeat-1); 48 | print(paste("n = ", n, " k = ", k , " mean1 = ", mean1, " var1 = ", var1, " mean2 = ", mean2, " var2 = ", var2, sep="")) 49 | } -------------------------------------------------------------------------------- /5장. 점 추정론/표 2. 오염정규분포에서 두 통게량 T1과 T2의 비교/contam2.iml: -------------------------------------------------------------------------------- 1 | /* Sampling from Contaminated Normal Distributions */ 2 | /* contam2.iml */ 3 | 4 | proc iml; 5 | theta = 10; sigma = 1; n = 40; n1 = n*0.9; 6 | Nrepeat = 1000; 7 | 8 | start stats; /* Computing Median and Mean */ 9 | r = rank(x); x1 = j(n,1,0); 10 | do i=1 to n; x1[r[i]] = x[i]; end; 11 | if mod(n,2) = 0 then median = (x1[n/2] + x1[n/2+1])/2; 12 | else median = x1[(n+1)/2]; 13 | mean = sum(x)/n; 14 | finish; 15 | 16 | do k = 1 to 5; 17 | x = j(n,1,0); M1 = j(Nrepeat,1,0); M2 = j(Nrepeat,1,0); 18 | 19 | /* Monte-Carlo Generation of Contaminated Samples */ 20 | do repeat=1 to Nrepeat; 21 | do i=1 to n1; x[i] = theta + sigma*normal(0); end; 22 | do i=n1+1 to n; x[i] = theta + k*sigma*normal(0); end; 23 | run stats; 24 | M1[repeat] = mean; M2[repeat] = median; 25 | end; 26 | mean1 = sum(M1)/Nrepeat; 27 | var1 = (ssq(M1) - Nrepeat*mean1*mean1)/(Nrepeat-1); 28 | mean2 = sum(M2)/Nrepeat; 29 | var2 = (ssq(M2) - Nrepeat*mean2*mean2)/(Nrepeat-1); 30 | print n k mean1[format=9.2] var1[format=9.4] mean2[format=9.2] var2[format=9.4]; 31 | end; 32 | quit; 33 | -------------------------------------------------------------------------------- /8장. 통계적 모형론/표 4. 독성실험 자료의 로짓 모형 분석을 위한 프로그램/logit.iml: -------------------------------------------------------------------------------- 1 | /* Logit Model Fitting */ 2 | /* File Name : logit.iml */ 3 | 4 | proc iml; 5 | X = {1 1.691, 1 1.691, 6 | 1 1.724, 1 1.724, 7 | 1 1.755, 1 1.755, 8 | 1 1.784, 1 1.784, 9 | 1 1.811, 1 1.811, 10 | 1 1.837, 1 1.837, 11 | 1 1.861, 1 1.861, 12 | 1 1.884, 1 1.884}; 13 | y = {1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0}; 14 | count = {6, 53, 13, 47, 18, 44, 28, 38, 52, 11, 53, 6, 61, 1, 60, 0}; 15 | 16 | beta_old = {0, 0}; tol = 1; repeat=1; 17 | 18 | do while (tol > 0.000001); 19 | eta = X* beta_old; 20 | bprime1 = exp(eta)/(1+exp(eta)); 21 | bprime2 = bprime1/(1+exp(eta)); 22 | I = X`*diag(count#bprime2)*X; 23 | Iinverse = inv(I); 24 | U = X`*diag(count)*(y-bprime1); 25 | beta_new = beta_old + Iinverse*X`*diag(count)*(y-bprime1); 26 | diff = beta_new - beta_old; 27 | tol = ssq(diff); 28 | print repeat beta_new[format=8.4]; 29 | repeat = repeat+1; 30 | beta_old = beta_new; 31 | end; 32 | 33 | loglik = 2*(eta`*diag(count)*y - count`*log(1+exp(eta))); 34 | se = sqrt(vecdiag(Iinverse)); 35 | print loglik[format=8.4] se[format=8.4]; 36 | quit; 37 | -------------------------------------------------------------------------------- /9장. 특수 토픽/표 1. 후버의 M-추정치를 구하기 위한 프로그램/robust.iml: -------------------------------------------------------------------------------- 1 | /* FileName: robust.iml */ 2 | /* Huber's M-estimation */ 3 | 4 | proc iml; 5 | x = {20 25 25 27 28 31 33 34 36 37 44 50 59 85 86}; 6 | n = ncol(x); 7 | mean = x[,+]/n; sd = sqrt((ssq(x)-n*mean*mean)/(n-1)); 8 | y = j(1,n,0); r = rank(x); 9 | do i=1 to n; y[r[i]] = x[i]; end; 10 | if mod(n,2) ^= 0 then median = y[(n+1)/2]; 11 | else median = (y[n/2] + y[n/2+1])/2; 12 | x1 = abs(x - median*j(1,n,1)); 13 | r1 = rank(x1); 14 | do i=1 to n; y[r1[i]] = x1[i]; end; 15 | if mod(n,2) ^= 0 then mad = y[(n+1)/2]/0.6745; 16 | else mad = (y[n/2] + y[n/2+1])/2/0.6745; 17 | print n mean[format=8.2] sd[format=8.2] median mad[format=8.2]; 18 | 19 | k = 1.5; theta0 = median; iter=0; diff=1; 20 | do while (diff > 0.0001); 21 | temp = (x-theta0*j(1,n,1))/mad; 22 | num = temp; denum = j(1,n,1); 23 | do i = 1 to n; 24 | if temp[i] > k then num[i] = k; 25 | else if temp[i] < -k then num[i] = -k; 26 | if abs(temp[i]) > k then denum[i] = 0; 27 | end; 28 | theta = theta0 + mad*sum(num)/sum(denum); 29 | diff = abs(theta-theta0); 30 | iter = iter+1; 31 | theta0 = theta; 32 | end; 33 | se = mad*sqrt(sum(num#num)/(sum(denum)*sum(denum))); 34 | print "Huber's M-estimate" iter theta[format=8.2] se[format=8.2]; 35 | quit; 36 | -------------------------------------------------------------------------------- /2장. 기본적인 확률도구 5개/표 7. 몬테칼로 방법으로 t 분포의 분위수 구하기/ttt.R: -------------------------------------------------------------------------------- 1 | n = 10; 2 | Nrepeat1 = 999; 3 | Nrepeat2 = 100; 4 | 5 | t025 = rep(0, Nrepeat2) 6 | t050 = rep(0, Nrepeat2) 7 | t100 = rep(0, Nrepeat2) 8 | 9 | 10 | for (i in 1:Nrepeat2) 11 | { 12 | T = rep(0, Nrepeat2) 13 | S = rep(0, Nrepeat2) 14 | 15 | for (j in 1:Nrepeat1) 16 | { 17 | sum1 = 0; sum2 = 0; 18 | 19 | for (k in 1:n) 20 | { 21 | x = runif(1)*2-1; 22 | # x = -2*log(1-uniform(0))+2*log(1-uniform(0)); # case2 23 | # x = normal(0); # case3 24 | sum1 = sum1 + x; 25 | sum2 = sum2 + x*x; 26 | } 27 | xbar = sum1/n; 28 | s2 = (sum2 - n*xbar*xbar)/(n-1); 29 | T[j] = abs(xbar/sqrt(s2/n)) 30 | } 31 | 32 | R = rank(T, ties.method="random"); 33 | for (j in 1:Nrepeat1) 34 | { 35 | S[R[j]] = T[j]; 36 | } 37 | t025[i] = S[0.95*(Nrepeat1+1)]; 38 | t050[i] = S[0.90*(Nrepeat1+1)]; 39 | t100[i] = S[0.80*(Nrepeat1+1)]; 40 | } 41 | 42 | t100m = sum(t100)/Nrepeat2; 43 | t100s = sqrt((sum(t100^2)-Nrepeat2*t100m*t100m)/(Nrepeat2*(Nrepeat2-1))); 44 | t050m = sum(t050)/Nrepeat2; 45 | t050s = sqrt((sum(t050^2)-Nrepeat2*t050m*t050m)/(Nrepeat2*(Nrepeat2-1))); 46 | t025m = sum(t025)/Nrepeat2; 47 | t025s = sqrt((sum(t025^2)-Nrepeat2*t025m*t025m)/(Nrepeat2*(Nrepeat2-1))); 48 | 49 | 50 | t100m 51 | t100s 52 | t050m 53 | t050s 54 | t025m 55 | t025s 56 | -------------------------------------------------------------------------------- /7장. 구간 추정론/표 2. 포아송 표본에서 신뢰구간을 구하기 위한 프로그램/conf2.R: -------------------------------------------------------------------------------- 1 | n = 4; s = 22; 2 | 3 | ### for upper limit 4 | ntheta0=0.01; ntheta1=20*n; diff=1; iter=1; 5 | while(diff > 0.0001) 6 | { 7 | ntheta = (ntheta0+ntheta1)/2; 8 | temp1 = 1; temp2 = exp(-ntheta); 9 | cumprob = temp2; 10 | for (k in 1:s) 11 | { 12 | temp1 = temp1*ntheta/k; 13 | prob = temp1*temp2; 14 | cumprob = cumprob + prob; 15 | } 16 | diff = abs(cumprob-0.025); 17 | theta = ntheta/n; 18 | 19 | if (cumprob < 0.025) { print(paste("Upper : iter = ", iter, " cumprob = ", cumprob, " theta = ", theta, sep="")) } 20 | 21 | if (cumprob > 0.025) { ntheta0 = ntheta; } 22 | else { ntheta1 = ntheta; } 23 | 24 | iter = iter + 1; 25 | } 26 | 27 | 28 | 29 | ### for lower limit 30 | ntheta0=0.01; ntheta1=20*n; diff=1; iter=1; 31 | while(diff > 0.0001) 32 | { 33 | ntheta=(ntheta0+ntheta1)/2; 34 | temp1 = 1; temp2 = exp(-ntheta); 35 | cumprob = temp2; 36 | for (k in 1:(s-1)) 37 | { 38 | temp1 = temp1*ntheta/k; 39 | prob = temp1*temp2; 40 | cumprob = cumprob + prob; 41 | } 42 | diff = abs(cumprob-0.975); 43 | theta = ntheta/n; 44 | 45 | if (cumprob < 0.975) { print(paste("Lower : iter = ", iter, " cumprob = ", cumprob, " theta = ", theta, sep="")) } 46 | 47 | if (cumprob > 0.975) { ntheta0 = ntheta; } 48 | else { ntheta1 = ntheta; } 49 | 50 | iter = iter + 1; 51 | } 52 | -------------------------------------------------------------------------------- /6장. 가설 검증론/표 1. 대표본 검증통계량의 몬테칼로 p-값 계산/glrt.iml: -------------------------------------------------------------------------------- 1 | /* GLRT, Wald and Score Testing for Multinomial Distribution */ 2 | /* glrt.iml */ 3 | 4 | proc iml; 5 | Nrepeat = 1000; 6 | E = {90,30,30,10}; 7 | n = sum(E); 8 | count0=0; count1=0; count2=0; count3=0; 9 | do repeat=1 to Nrepeat; 10 | F = j(4,1,0); 11 | do i=1 to n; 12 | temp = uniform(0); 13 | if temp <= 9/16 then F[1,1]=F[1,1]+1; 14 | else if temp <= 12/16 then F[2,1]=F[2,1]+1; 15 | else if temp <= 15/16 then F[3,1]=F[3,1]+1; 16 | else F[4,1]=F[4,1]+1; 17 | end; 18 | if min(F) ^= 0 then do; 19 | count0=count0 +1; 20 | G = 2*sum(F#log(F/E)); 21 | W = sum((F-E)#(F-E)/F); 22 | S = sum((F-E)#(F-E)/E); 23 | if G >= 9.30 then count1=count1+1; 24 | if W >= 9.52 then count2=count2+1; 25 | if S >= 9.44 then count3=count3+1; 26 | end; 27 | end; 28 | pvalue1 = count1/count0; 29 | pvalue2 = count2/count0; 30 | pvalue3 = count3/count0; 31 | pvalue1a = 1-probchi(9.30,3); 32 | pvalue2a = 1-probchi(9.52,3); 33 | pvalue3a = 1-probchi(9.44,3); 34 | 35 | print "Monte-Carlo" count0 Nrepeat pvalue1 pvalue2 pvalue3; 36 | print "Large-Sample" pvalue1a[format=8.3] pvalue2a[format=8.3] pvalue3a[format=8.3]; 37 | quit; 38 | -------------------------------------------------------------------------------- /5장. 점 추정론/표 3. mle hat_theta의 모의분를 만들기 위한 프로그램(theta=0.5, n=40)/angular.R: -------------------------------------------------------------------------------- 1 | Nrepeat = 100; ttheta = 0.5; n = 20; # ttheta = true theta value 2 | MLE = rep(0, Nrepeat); 3 | 4 | for (i in 1:Nrepeat) 5 | { 6 | ncount = 1; x = rep(0, n); 7 | 8 | while (ncount <= n) 9 | { 10 | xtemp = 2*runif(1)-1; y = runif(1); ytemp = (1+ttheta*xtemp)/2; 11 | if (y <= ytemp) { x[ncount] = xtemp; ncount = ncount + 1; } 12 | } 13 | 14 | theta = 0; # user-supplied initial value 15 | maxtol = 0.0001; maxiter = 10000; 16 | 17 | ell = function(x, theta) 18 | { 19 | lik = 0; lik1 = 0; lik2 = 0; 20 | for (j in 1:n) 21 | { 22 | lik1 = lik1 + x[j]/(1+theta*x[j]); # user-supplied first derivative 23 | lik2 = lik2 - (x[j]/(1+theta*x[j]))**2; # user-supplied second derivative 24 | } 25 | 26 | result = list(lik = lik, lik1 = lik1, lik2 = lik2) 27 | return(result) 28 | } 29 | 30 | 31 | iter = 0 32 | tol = 1 33 | 34 | while ((iter <= maxiter) && (tol > maxtol)) 35 | { 36 | theta1 = theta - ell(x, theta)$lik1/ell(x, theta)$lik2; 37 | tol = abs(theta1 - theta); 38 | theta = theta1; 39 | m = 3*sum(x)/n; 40 | iter = iter + 1; 41 | } 42 | 43 | if (theta <= -1) { theta = -1; } 44 | if (theta >= 1) { theta = 1; } 45 | 46 | MLE[i] = theta; 47 | } 48 | 49 | mean0 = sum(MLE) / Nrepeat; 50 | variance0 = (sum(MLE^2) - Nrepeat*mean0*mean0)/(Nrepeat-1); 51 | 52 | MLE 53 | Nrepeat 54 | n 55 | ttheta 56 | mean0 57 | variance0 58 | -------------------------------------------------------------------------------- /7장. 구간 추정론/표 2. 포아송 표본에서 신뢰구간을 구하기 위한 프로그램/conf2.iml: -------------------------------------------------------------------------------- 1 | /* Confidence Interval for Poisson Case with n = 4 and s = 57 */ 2 | /* File Name : conf2.iml */ 3 | 4 | proc iml; 5 | n = 4; s = 22; 6 | /* for upper limit */ 7 | ntheta0=0.01; ntheta1=20*n; diff=1; iter=1; 8 | do while (diff > 0.0001); 9 | ntheta=(ntheta0+ntheta1)/2; 10 | temp1 = 1; temp2 = exp(-ntheta); 11 | cumprob = temp2; 12 | do k=1 to s; 13 | temp1 = temp1*ntheta/k; 14 | prob = temp1*temp2; 15 | cumprob = cumprob + prob; 16 | end; 17 | diff = abs(cumprob-0.025); 18 | theta = ntheta/n; 19 | if cumprob < 0.025 then 20 | print "upper" iter cumprob[format=8.4] theta[format=8.4]; 21 | if cumprob > 0.025 then ntheta0 = ntheta; 22 | else ntheta1=ntheta; 23 | iter = iter + 1; 24 | end; 25 | 26 | /* for lower limit */ 27 | ntheta0=0.01; ntheta1=20*n; diff=1; iter=1; 28 | do while (diff > 0.0001); 29 | ntheta=(ntheta0+ntheta1)/2; 30 | temp1 = 1; temp2 = exp(-ntheta); 31 | cumprob = temp2; 32 | do k=1 to s-1; 33 | temp1 = temp1*ntheta/k; 34 | prob = temp1*temp2; 35 | cumprob = cumprob + prob; 36 | end; 37 | diff = abs(cumprob-0.975); 38 | theta = ntheta/n; 39 | if cumprob < 0.975 then 40 | print "lower" iter cumprob[format=8.4] theta[format=8.4]; 41 | if cumprob > 0.975 then ntheta0 = ntheta; 42 | else ntheta1 = ntheta; 43 | iter = iter + 1; 44 | end; 45 | quit; 46 | -------------------------------------------------------------------------------- /4장. 가능도(Likelihood); 개념, 계산, 속성/표 3. 2개 파라미터의 최대가능도 추정; 뉴튼-라프슨 방법/mle2.R: -------------------------------------------------------------------------------- 1 | theta1 = 1; theta2 = 8.67; # user-supplied initial values 2 | theta = rbind(theta1, theta2); # theta = theta1//theta2; 3 | maxtol = 0.0001; maxiter = 10000; 4 | 5 | ell = function(theta1, theta2) 6 | { 7 | x = c(1, 1, 2, 2, 3, 4, 4, 5, 5, 8, 8, 8, 8, 11, 11, 12, 12, 15, 17, 22, 23); 8 | n = 21; 9 | temp0 = exp(theta1*log(x)); 10 | temp1 = exp(theta1*log(x))*log(x); 11 | temp2 = exp(theta1*log(x))*log(x)*log(x); 12 | 13 | # user-supplied log-likelihood function 14 | lik = n*log(theta1/theta2) + (theta1-1)*sum(log(x)) - sum(temp0)/theta2; 15 | 16 | # user-supplied first derivatives 17 | lik1 = n/theta1 + sum(log(x)) - sum(temp1)/theta2; 18 | lik2 =-n/theta2 + sum(temp0)/(theta2*theta2); 19 | 20 | # user-supplied second derivatives 21 | lik11 = -n/(theta1*theta1) - sum(temp2)/theta2; 22 | lik22 = n/(theta2*theta2) - 2*sum(temp0)/(theta2*theta2*theta2); 23 | lik12 = sum(temp1)/(theta2*theta2); 24 | 25 | # gradient and Hessian matrix 26 | grad = rbind(lik1, lik2); # grad = lik1//lik2; 27 | Hess = rbind(cbind(lik11, lik12) , cbind(lik12, lik22)); # Hess = (lik11||lik12)//(lik12||lik22); 28 | 29 | result = list(grad = grad, Hess = Hess) 30 | return(result) 31 | } 32 | 33 | iter = 0; 34 | tol = 1; 35 | while ((iter <= maxiter) && (tol > maxtol)) 36 | { 37 | update0 = theta - solve(ell(theta1, theta2)$Hess)%*%ell(theta1, theta2)$grad; 38 | tol = sum((update0 - theta)^2); 39 | theta = update0; 40 | theta1 = theta[1]; 41 | theta2 = theta[2]; 42 | iter = iter + 1; 43 | } 44 | 45 | 46 | iter 47 | theta 48 | ell(theta1, theta2) 49 | -------------------------------------------------------------------------------- /5장. 점 추정론/표 3. mle hat_theta의 모의분를 만들기 위한 프로그램(theta=0.5, n=40)/angular.iml: -------------------------------------------------------------------------------- 1 | /* Simulation of Angular Observations and MLE's */ 2 | /* angular.iml */ 3 | 4 | proc iml; 5 | Nrepeat = 100; ttheta = 0.5; n = 20; /*ttheta = true theta value */ 6 | MLE = j(Nrepeat, 1, 0); 7 | 8 | do repeat = 1 to Nrepeat; 9 | ncount = 1; x = j(n,1,0); 10 | do while (ncount <= n); 11 | xtemp = 2*uniform(0)-1; y = uniform(0); ytemp = (1+ttheta*xtemp)/2; 12 | if y <= ytemp then do; x[ncount] = xtemp; ncount = ncount + 1; end; 13 | end; 14 | 15 | theta = 0; /* user-supplied initial value */ 16 | maxtol = 0.0001; maxiter = 10000; 17 | 18 | start ell; 19 | lik = 0; lik1 = 0; lik2 = 0; 20 | do i=1 to n; 21 | lik1 = lik1 + x[i]/(1+theta*x[i]); /* user-supplied first derivative */ 22 | lik2 = lik2 - (x[i]/(1+theta*x[i]))**2; /* user-supplied second derivative */ 23 | end; 24 | finish; 25 | 26 | iter = 0; 27 | tol = 1; 28 | do while (iter <= maxiter & tol > maxtol); 29 | 30 | run ell; 31 | theta1 = theta - lik1/lik2; 32 | tol = abs(theta1 - theta); 33 | theta = theta1; 34 | m = 3*sum(x)/n; 35 | iter = iter + 1; 36 | end; 37 | 38 | if theta <= -1 then theta = -1; 39 | if theta >= 1 then theta = 1; 40 | MLE[repeat,1] = theta; 41 | end; 42 | 43 | mean = sum(MLE) / Nrepeat; 44 | variance = (ssq(MLE) - Nrepeat*mean*mean)/(Nrepeat-1); 45 | 46 | print MLE; 47 | print Nrepeat n ttheta mean variance; 48 | quit; 49 | -------------------------------------------------------------------------------- /9장. 특수 토픽/표 2. M-추정치의 붓스트랩 분포를 구하기 위한 프로그램/boots.R: -------------------------------------------------------------------------------- 1 | x = c(20, 25, 25, 27, 28, 31, 33, 34, 36, 37, 44, 50, 59, 85, 86) 2 | n = length(x); 3 | B = 999; 4 | theta_M = rep(0, B); 5 | xstar = rep(0, n); 6 | 7 | 8 | for (ii in 1:B) 9 | { 10 | n = length(x); 11 | for (i in 1:n) 12 | { 13 | xstar[i] = x[as.integer(n*runif(1))+1]; 14 | } 15 | 16 | mean0 = sum(xstar)/n; 17 | 18 | y = rep(0,n); r = rank(xstar, ties.method="random"); 19 | for (i in 1:n) { y[r[i]] = xstar[i]; } 20 | median0 = ifelse( (n%/%2) != 0, y[(n+1)/2], (y[n/2] + y[n/2+1])/2 ) 21 | 22 | x1 = abs(xstar - median0*rep(1,n)); 23 | r1 = rank(x1, ties.method="random"); 24 | for (i in 1:n) { y[r1[i]] = x1[i]; } 25 | mad0 = ifelse( (n%/%2) != 0, y[(n+1)/2]/0.6745, ((y[n/2] + y[n/2+1])/2)/0.6745 ) 26 | 27 | k = 1.5; theta0 = median0; iter=0; diff0=1; 28 | 29 | while (diff0 > 0.0001) 30 | { 31 | temp = (xstar-theta0*rep(1,n))/mad0; 32 | num = temp; denum = rep(1,n); 33 | 34 | for (i in 1:n) 35 | { 36 | if( temp[i] > k ) { num[i] = k; } 37 | else if (temp[i] < -k ) { num[i] = -k; } 38 | 39 | if (abs(temp[i]) > k) { denum[i] = 0; } 40 | } 41 | 42 | theta = theta0 + mad0*sum(num)/sum(denum); 43 | diff0 = abs(theta-theta0); 44 | iter = iter+1; 45 | theta0 = theta; 46 | } 47 | 48 | theta_M[ii] = theta; 49 | } 50 | 51 | 52 | m1 = sum(theta_M)/B; 53 | se = sqrt((sum(theta_M^2)-B*m1*m1)/(B-1)); 54 | 55 | m1 56 | se 57 | 58 | theta_O = rep(0, B); r2 = rank(theta_M, ties.method="random"); 59 | for (k in 1:B) { theta_O[r2[k]] = theta_M[k]; } 60 | l=theta_O[(B+1)*0.025]; u=theta_O[(B+1)*0.975]; 61 | 62 | l 63 | u 64 | 65 | hist(theta_M) # 그림 2. M-추정량의 붓스트랩 분포 -------------------------------------------------------------------------------- /4장. 가능도(Likelihood); 개념, 계산, 속성/표 3. 2개 파라미터의 최대가능도 추정; 뉴튼-라프슨 방법/mle2.iml: -------------------------------------------------------------------------------- 1 | /* Newton-Raphson method for two parameters */ 2 | /* mle2.iml */ 3 | 4 | proc iml; 5 | theta1 = 1; theta2 = 8.67; /* user-supplied initial values */ 6 | theta = theta1//theta2; 7 | maxtol = 0.0001; maxiter = 10000; 8 | 9 | start ell; 10 | x={1 1 2 2 3 4 4 5 5 8 8 8 8 11 11 12 12 15 17 22 23}; 11 | n = 21; 12 | temp0 = exp(theta1*log(x)); 13 | temp1 = exp(theta1*log(x))#log(x); 14 | temp2 = exp(theta1*log(x))#log(x)#log(x); 15 | 16 | /* user-supplied log-likelihood function */ 17 | lik = n*log(theta1/theta2) + (theta1-1)*sum(log(x)) - sum(temp0)/theta2; 18 | 19 | /* user-supplied first derivatives */ 20 | lik1 = n/theta1 + sum(log(x)) - sum(temp1)/theta2; 21 | lik2 =-n/theta2 + sum(temp0)/(theta2*theta2); 22 | 23 | /* user-supplied second derivatives */ 24 | lik11 = -n/(theta1*theta1) - sum(temp2)/theta2; 25 | lik22 = n/(theta2*theta2) - 2*sum(temp0)/(theta2*theta2*theta2); 26 | lik12 = sum(temp1)/(theta2*theta2); 27 | 28 | /* gradient and Hessian matrix */ 29 | grad = lik1//lik2; 30 | Hess = (lik11||lik12)//(lik12||lik22); 31 | finish; 32 | 33 | iter = 0; 34 | tol = 1; 35 | do while (iter <= maxiter & tol > maxtol); 36 | run ell; 37 | update = theta - inv(Hess)*grad; 38 | tol = ssq(update - theta); 39 | theta = update; 40 | theta1 = theta[1]; 41 | theta2 = theta[2]; 42 | iter = iter + 1; 43 | end; 44 | 45 | print iter theta[format=12.4] grad[format=12.4] lik[format=12.4]; 46 | quit; 47 | -------------------------------------------------------------------------------- /3장. 재미있는 확률문제 5개/표 5. 산불과정을 보기 위한 몬테칼로 프로그램/fire.iml: -------------------------------------------------------------------------------- 1 | /* Forest Fire Process Simulation */ 2 | /* fire.iml */ 3 | 4 | proc iml; 5 | p = 0.5; n=20; 6 | nn = 2*n+1; 7 | FIRE1 = j(nn,nn,'.'); 8 | FIRE2 = j(nn,nn,'.'); 9 | MAP = j(nn,nn,'.'); 10 | status = 1; 11 | FIRE1[n+1,n+1] = '0'; 12 | time = 0; 13 | do while (status > 0); 14 | status = 0; 15 | do i1 = 1 to nn; 16 | do i2 = 1 to nn; 17 | if FIRE1[i1,i2] = '0' then do; 18 | if (i1 < nn) then do; 19 | if (uniform(0) < p) & (MAP[i1+1,i2] = '.') then 20 | do; FIRE2[i1+1,i2] = '0'; status = 1; end; end; 21 | if (i1 > 1) then do; 22 | if (uniform(0) < p) & (MAP[i1-1,i2] = '.') then 23 | do; FIRE2[i1-1,i2] = '0'; status = 1; end; end; 24 | if (i2 < nn) then do; 25 | if (uniform(0) < p) & (MAP[i1,i2+1] = '.') then 26 | do; FIRE2[i1,i2+1] = '0'; status = 1; end; end; 27 | if (i2 > 1) then do; 28 | if (uniform(0) < p) & (MAP[i1,i2-1] = '.') then 29 | do; FIRE2[i1,i2-1] = '0'; status = 1; end; end; 30 | MAP[i1,i2] = '1'; 31 | end; 32 | end; 33 | end; 34 | FIRE1 = FIRE2; 35 | FIRE2 = j(nn,nn,'.'); 36 | time = time + 1; 37 | /* print time MAP[format=1.0]; */ 38 | /* print time FIRE1[format=1.0]; */ 39 | end; 40 | count=0; 41 | do i1 = 1 to nn; 42 | do i2 = 1 to nn; 43 | if MAP[i1,i2] = '1' then count=count+1; 44 | end; end; 45 | print time count, MAP[format=1.0]; 46 | quit; 47 | -------------------------------------------------------------------------------- /2장. 기본적인 확률도구 5개/표 7. 몬테칼로 방법으로 t 분포의 분위수 구하기/ttt.iml: -------------------------------------------------------------------------------- 1 | /* t, t, t distritubion for Uniform, Laplace and Normal Cases */ 2 | /* ttt.iml */ 3 | 4 | proc iml; 5 | n = 10; 6 | Nrepeat1 = 999; 7 | Nrepeat2 = 100; 8 | t025 = j(Nrepeat2,1,0); 9 | t050 = j(Nrepeat2,1,0); 10 | t100 = j(Nrepeat2,1,0); 11 | 12 | do repeat2=1 to Nrepeat2; 13 | T = j(Nrepeat1,1,0); 14 | S = j(Nrepeat1,1,0); 15 | do repeat1=1 to Nrepeat1; 16 | sum1 = 0; sum2 = 0; 17 | do sample=1 to n; 18 | x = uniform(0)*2-1; 19 | /* case2: x = -2*log(1-uniform(0))+2*log(1-uniform(0)); */ 20 | /* case3: x = normal(0); */ 21 | sum1 = sum1 + x; 22 | sum2 = sum2 + x*x; 23 | end; 24 | xbar = sum1/n; 25 | s2 = (sum2 - n*xbar*xbar)/(n-1); 26 | t[repeat1] = abs(xbar/sqrt(s2/n)); 27 | end; 28 | 29 | R = rank(T); 30 | do repeat1=1 to Nrepeat1; 31 | S[R[repeat1]] = T[repeat1]; 32 | end; 33 | t025[repeat2] = S[0.95*(Nrepeat1+1)]; 34 | t050[repeat2] = S[0.90*(Nrepeat1+1)]; 35 | t100[repeat2] = S[0.80*(Nrepeat1+1)]; 36 | end; 37 | 38 | t100m = sum(t100)/Nrepeat2; 39 | t100s = sqrt((ssq(t100)-Nrepeat2*t100m*t100m)/(Nrepeat2*(Nrepeat2-1))); 40 | t050m = sum(t050)/Nrepeat2; 41 | t050s = sqrt((ssq(t050)-Nrepeat2*t050m*t050m)/(Nrepeat2*(Nrepeat2-1))); 42 | t025m = sum(t025)/Nrepeat2; 43 | t025s = sqrt((ssq(t025)-Nrepeat2*t025m*t025m)/(Nrepeat2*(Nrepeat2-1))); 44 | 45 | print Nrepeat1 Nrepeat2 t100m[format=8.4] t100s[format=8.4]; 46 | print Nrepeat1 Nrepeat2 t050m[format=8.4] t050s[format=8.4]; 47 | print Nrepeat1 Nrepeat2 t025m[format=8.4] t025s[format=8.4]; 48 | 49 | quit; 50 | -------------------------------------------------------------------------------- /9장. 특수 토픽/표 2. M-추정치의 붓스트랩 분포를 구하기 위한 프로그램/boots.iml: -------------------------------------------------------------------------------- 1 | /* FileName: boots.iml */ 2 | /* Huber's M-estimation */ 3 | 4 | proc iml; 5 | 6 | x = {20 25 25 27 28 31 33 34 36 37 44 50 59 85 86}; 7 | n = ncol(x); 8 | B = 999; 9 | theta_M = j(B,1,0); 10 | xstar = j(1,n,0); 11 | 12 | start boots; 13 | do i=1 to n; xstar[i] = x[int(n*ranuni(0))+1]; end; 14 | 15 | mean = xstar[,+]/n; ; 16 | y = j(1,n,0); r = rank(xstar); 17 | do i=1 to n; y[r[i]] = xstar[i]; end; 18 | if mod(n,2) ^= 0 then median = y[(n+1)/2]; 19 | else median = (y[n/2] + y[n/2+1])/2; 20 | x1 = abs(xstar - median*j(1,n,1)); 21 | r1 = rank(x1); 22 | do i=1 to n; y[r1[i]] = x1[i]; end; 23 | if mod(n,2) ^= 0 then mad = y[(n+1)/2]/0.6745; 24 | else mad = (y[n/2] + y[n/2+1])/2/0.6745; 25 | k = 1.5; theta0 = median; iter=0; diff=1; 26 | do while (diff > 0.0001); 27 | temp = (xstar-theta0*j(1,n,1))/mad; 28 | num = temp; denum = j(1,n,1); 29 | do i = 1 to n; 30 | if temp[i] > k then num[i] = k; 31 | else if temp[i] < -k then num[i] = -k; 32 | if abs(temp[i]) > k then denum[i] = 0; 33 | end; 34 | theta = theta0 + mad*sum(num)/sum(denum); 35 | diff = abs(theta-theta0); 36 | iter = iter+1; 37 | theta0 = theta; 38 | end; 39 | theta_M[repeat] = theta; 40 | finish; 41 | 42 | do repeat=1 to B; run boots; end; 43 | print theta_M[format=8.2]; 44 | 45 | m1 = theta_M[+,]/B; 46 | se = sqrt((ssq(theta_M)-B*m1*m1)/(B-1)); 47 | print m1[format=8.2] se[format=8.2]; 48 | 49 | theta_O = j(B,1,0); r2 = rank(theta_M); 50 | do k=1 to B; theta_O[r2[k]] = theta_M[k]; end; 51 | l=theta_O[(B+1)*0.025]; u=theta_O[(B+1)*0.975]; 52 | print l[format=8.2] u[format=8.2]; 53 | 54 | quit; 55 | -------------------------------------------------------------------------------- /3장. 재미있는 확률문제 5개/표 5. 산불과정을 보기 위한 몬테칼로 프로그램/fire.R: -------------------------------------------------------------------------------- 1 | p = 0.5; n=20; 2 | nn = 2*n+1; 3 | FIRE1 = matrix('.', nn,nn); 4 | FIRE2 = matrix('.', nn,nn); 5 | MAP = matrix('.', nn,nn); 6 | status = 1; 7 | FIRE1[n+1,n+1] = '0'; 8 | time = 0; 9 | 10 | while (status > 0) 11 | { 12 | status = 0; 13 | 14 | for (i1 in 1:nn) 15 | { 16 | for (i2 in 1:nn) 17 | { 18 | if (FIRE1[i1,i2] == '0') 19 | { 20 | if (i1 < nn) 21 | { 22 | if ((runif(1) < p) && (MAP[i1+1,i2] == '.')) { FIRE2[i1+1,i2] = '0'; status = 1; } 23 | } 24 | 25 | if (i1 > 1) 26 | { 27 | if ((runif(1) < p) && (MAP[i1-1,i2] == '.')) { FIRE2[i1-1,i2] = '0'; status = 1; } 28 | } 29 | 30 | if (i2 < nn) 31 | { 32 | if ((runif(1) < p) && (MAP[i1,i2+1] == '.')) { FIRE2[i1,i2+1] = '0'; status = 1; } 33 | } 34 | 35 | if (i2 > 1) 36 | { 37 | if ((runif(1) < p) && (MAP[i1,i2-1] == '.')) { FIRE2[i1,i2-1] = '0'; status = 1; } 38 | } 39 | 40 | MAP[i1,i2] = '1'; 41 | } 42 | } 43 | } 44 | 45 | FIRE1 = FIRE2; 46 | FIRE2 = matrix('.', nn,nn); 47 | time = time + 1; 48 | # print time MAP[format=1.0]; 49 | # print time FIRE1[format=1.0]; 50 | } 51 | 52 | count=0; 53 | for (i1 in 1:nn) 54 | { 55 | for (i2 in 1:nn) 56 | { 57 | if (MAP[i1,i2] == '1') { count=count+1; } 58 | } 59 | } 60 | 61 | data.frame(MAP) 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | ##### 아래는 조금 더 Graphical하게 출력하여 보았습니다. : 유재성 73 | p = 0.5; n=20; 74 | nn = 2*n+1; 75 | FIRE1 = matrix('.', nn,nn); 76 | FIRE2 = matrix('.', nn,nn); 77 | MAP = matrix('.', nn,nn); 78 | status = 1; 79 | FIRE1[n+1,n+1] = '0'; 80 | time = 0; 81 | 82 | while (status > 0) 83 | { 84 | status = 0; 85 | 86 | for (i1 in 1:nn) 87 | { 88 | for (i2 in 1:nn) 89 | { 90 | if (FIRE1[i1,i2] == '0') 91 | { 92 | if (i1 < nn) 93 | { 94 | if ((runif(1) < p) && (MAP[i1+1,i2] == '.')) { FIRE2[i1+1,i2] = '0'; status = 1; } 95 | } 96 | 97 | if (i1 > 1) 98 | { 99 | if ((runif(1) < p) && (MAP[i1-1,i2] == '.')) { FIRE2[i1-1,i2] = '0'; status = 1; } 100 | } 101 | 102 | if (i2 < nn) 103 | { 104 | if ((runif(1) < p) && (MAP[i1,i2+1] == '.')) { FIRE2[i1,i2+1] = '0'; status = 1; } 105 | } 106 | 107 | if (i2 > 1) 108 | { 109 | if ((runif(1) < p) && (MAP[i1,i2-1] == '.')) { FIRE2[i1,i2-1] = '0'; status = 1; } 110 | } 111 | 112 | MAP[i1,i2] = '1'; 113 | } 114 | } 115 | } 116 | 117 | FIRE1 = FIRE2; 118 | FIRE2 = matrix('.', nn,nn); 119 | time = time + 1; 120 | # print(MAP); 121 | # print(FIRE1) 122 | 123 | 124 | 125 | # print(data.frame(MAP)) # Console에서도 출력하려면, 이 부분의 주석을 풀어주면 됩니다.: 유재성 126 | 127 | # 아래는 그림을 그려주는 부분입니다. 128 | tempMAP = MAP 129 | tempMAP[tempMAP=="."] = 0; tempMAP[tempMAP=="1"] = 1; tempMAP = apply(tempMAP, 2, as.numeric) 130 | 131 | image(1:ncol(tempMAP), 1:nrow(tempMAP), t(tempMAP), col = terrain.colors(60), axes = FALSE) 132 | 133 | Sys.sleep (2) # 반복문 속도를 여기에서 조절하여 줄 수 있습니다.: 유재성 134 | } 135 | 136 | 137 | 138 | count=0; 139 | for (i1 in 1:nn) 140 | { 141 | for (i2 in 1:nn) 142 | { 143 | if (MAP[i1,i2] == '1') { count=count+1; } 144 | } 145 | } 146 | 147 | data.frame(MAP) 148 | 149 | tempMAP = MAP 150 | tempMAP[tempMAP=="."] = 0 151 | tempMAP[tempMAP=="1"] = 1 152 | tempMAP = apply(tempMAP, 2, as.numeric) 153 | 154 | image(1:ncol(tempMAP), 1:nrow(tempMAP), t(tempMAP), col = terrain.colors(60), axes = FALSE) --------------------------------------------------------------------------------