Syntax to define functions. The value returned by a function is the value of the function body, Syntax to call functions. myfct(arg1=..., arg2=...

Transcription

1 R 프로그래밍 II

2 Function: Definition A very useful feature of the R environment is the possibility to expand existing functions and to easily write custom functions. In fact, most of the R software can be viewed as a series of R functions. Syntax to define functions myfct <- function(arg1, arg2,...) { function_body } The value returned by a function is the value of the function body, which is usually an unassigned final expression, e.g.: g:return() Syntax to call functions myfct(arg1=..., arg2=...)

3 Function: Syntax Rules General Functions are defined by (1) assignment with the keyword 'function', (2) the declaration of arguments/variables (arg1, arg2,...) and (3) the definition of operations (function_body) that perform computations on the provided arguments. A function name ('myfct') needs to be assigned to call the function (see below). Naming Function names can be almost anything. However, the usage of names of existing functions should be avoided. Arguments It is often useful to provide default values for arguments (e.g.: 'arg1=1:10'). This way they don't need to be provided in a function call. The argument list can also be left empty ('myfct <- function() { fct_body }') when a function is expected to return always the same value(s). The argument '...' can be used to allow one function to pass on argument settings to another. Function body The actual expressions (commands/operations) are defined in the function body which should be enclosed by braces. The individual commands are separated by semicolons or new lines (preferred). Calling functions Functions are called by their name followed by parentheses containing possible argument names. Empty parenthesis after the function name will result in an error message when a function requires certain arguments to be provided by the user. The function name alone will print the definition of a function. Scope Variables created inside a function exist only for the life time of a function. Thus, they are not accessible outside of the function. To force variables in functions to exist globally, one can use this special assignment operator: '<<-'. If a global variable is used in a function, then the global variable will be masked only within the function.

4 Example: Function Basics myfct <- function(x1, x2=5) { z1 <- x1/x1; z2 <- x2*x2 myvec <- c(z1, z2) return(myvec) } myfct # prints definition of function myfct(x1=2, x2=5) # applies function to values 2 and 5 myfct(2, 5) # the argument names are not necessary, but then the order of the specified values becomes important myfct(x1=2) # does the same as before but the default value '5' is myfct(x1=2) # does the same as before, but the default value 5 is used in this case

5 Example: Function with Optional Arguments myfct2 <- function(x1=5, opt_arg) { if(missing(opt_arg)) { z1 <- 1:10 } else { z1 <- opt_arg } cat("my function returns:", "\n") ") return(z1/x1) } myfct2(x1=5) myfct2(x1=5, opt_arg=30:20)

6 Control Utilities for Functions Return The evaluation flow of a function may be terminated at any stage with the 'return()' function. This is often used in combination with conditional evaluations. Stop To stop the action of a function and print an error message, one can use the stop() function. Warning To print a warning message in unexpected situations i without aborting the evaluation flow of a function, one can use the function 'warning("...")'.

7 Example: Control Utilities myfct <- function(x1) ){ if (x1>=0) print(x1) else stop("this function did not finish, i because x1 < 0") warning("value needs to be > 0") } myfct(x1=2) myfct(x1=-2)

8 Matrix Algebra

9 Introduction > A = matrix(1:12, nrow=3, ncol=4) > A [,1] [,2] [,3] [,4] [1,] [2,] [3,] > diag(a) [] [1] > a <- c(1,2,3) > b <- c(1,2,3,4) > c <- 5 > a [1] > b [] [1] > c [1] 5 #Case-sensitive, but not necessary uppercase or lowerrcase for matrix and vector

10 Basic Operation > #Basic operation > A = matrix(1:16, nrow=4, ncol=4) > B = matrix(16:1, nrow=4, ncol=4) > A [,1] [,2] [,3] [,4] [1,] [2,] [3,] [4,] > t(a) #transpose [,1] [,2] [,3] [,4] [1,] [2,] [3,] [4,] > sum(diag(a)) #trace [1] 34

11 Basic Operation > A + B [,1] [,2] [,3] [,4] [1,] [2,] [3,] [4,] > A - B [,1] [,2] [,3] [,4] [1,] [2,] [3,] [4,]

12 Basic Operation > A * B [,1] [,2] [,3] [,4] [1,] [2,] [3,] [4,] > A %*% B [,1] [,2] [,3] [,4] [1,] [2,] [3,] [4,]

13 Basic Operation > a <- c(1,2,3,4) > b <- c(2,4,7,9) > a %*% A [,1] [,2] [,3] [,4] [1,] > a * b [1] > a %*% % b [,1] [1,] 67 > t(a) %*% b [,1] [1,] 67 > 2*A [,1] [,2] [,3] [,4] [1,] [2,] [3,] [4,]

14 Determinant/Inverse Matrix > A = matrix(1:4, nrow=2) #Determinat > A [,1] [,2] [1,] 1 3 [2,] 2 4 > det(a) [1] -2 >#Inverse matrix >#Inverse matrix > solve(a) [,1] [,2] [1,] [2,] 1-0.5

15 Matrix and Linear Equation > A = matrix(c(2,3,3,5), nrow=2, ncol=2) > A [,1] [,2] [1,] 2 3 [2,] 3 5 > b = c(7,11) > b [1] 7 11 > solve(a, b) [1] 2 1

16 Eigen Value and Vector > A = matrix(c(5,25,35,25,155,175,35,175,325), ( ncol=3) > A [,1] [,2] [,3] [1,] [2,] [3,] > EA = eigen(a, symmetric=t) > EA $values [1] $vectors [,1] [,2] [,3] [1,] [2,] [3,]

17 Solving Linear and Nonlinear Equations

18 Solving Linear Equations Using Gauss Elimination > A = matrix(c(4, ( 2, 1, -2, -1, 3, 3, 1, -1), ncol=3) > A [,1] [,2] [,3] [1,] [2,] [3,] > b=c(9, 3, 4) > b [1] > solve(a) [,1] [,2] [,3] [1,] [2,] [3,] > solve(a,b) [1] [] 1 2 3

19 Choleski Decomposition > X=matrix(c(1,1,1,1,1,2,9,6,3,5,6,10,4,13,2), ncol=3) > X [1] [,1] [2] [,2] [3] [,3] [1,] [2,] [3,] [4,] [5,] > XX=t(X) %*% X > XX [,1] [,2] [,3] [1,] [2,] [3,] > G = chol(xx) > G [,1] [,2] [,3] [1,] e+01 [2,] e-16 [3,] e+00 > t(g) %*% G [,1] [,2] [,3] [1,] [2,] [3,]

20 QR Decomposition > X=matrix(c(1,1,1,1,1,2,9,6,3,5,6,10,4,13,2), ncol=3) > X [,1] [,2] [,3] [1,] [2,] [3,] [4,] [5,] > y=c(62,60,57,48,23) > qrx=qr(x)

21 QR Decomposition > qr.q(qrx) [,1] [,2] [,3] [1,] e [2,] e [3,] e [4,] e [5,] e > qr.r(qrx) [,1] [,2] [,3] [1,] e+01 [2,] e-16 [3,] e+00 > t(qr.q(qrx)) %*% qr.q(qrx) [,1] [,2] [,3] [1,] [,] [2,] [3,] > qr.q(qrx) %*% qr.r(qrx) [,1] [,2] [,3] [1,] [2,] [3,] [4,] [5,] 1 5 2

22 Application to Regression Modeling > b=solve(t(x) %*% % X) %*% % t(x) %*% % y > b [,1] [1,] 37.0 [2,] 0.5 [3,] 1.5 > yhat = X %*% solve(t(x) %*% X) %*% t(x) %*% y > yhat [,1] [1,] 47.0 [2,] 56.5 [3,] 46.0 [4,] 58.0 [5,] 42.5 > e=(diag(length(y))-x %*% solve(t(x) %*% X) %*% t(x)) %*% y > e [,1] [1,] 15.0 [2,] 3.5 [3,] 11.0 [4,] [5,] -19.5

23 Bisection Method Bisection = function(x0, x1, epsilon = 1.0e-5) { fx0 = f(x0) fx1 = f(x1) if(fx0*fx1 >0) return("wrong initial iti values") error = abs(x1-x0) N = 1 while(error > epsilon) { N = N + 1 error = error /2 x2 = (x0+x1)/2 fx2=f(x2) if(fx0*fx2 < 0) { x1 = x2 fx1 = fx2 } else { x0 = x2 fx0 = fx2 } } return(list(x=x2, x2 n=n)) }

24 Bisection Method > f = function(x){x^2-3} > Bisection(1,2) $x [1] $n [1] 18

25 Newton-Raphson Method Newton=function(x0, epsilon=1.0e-5, n=100) { e = 1 N = 1 d = epsilon while(e > epsilon) { N = N + 1 if(n > n) return("not converge after 100 iterations") x1 = x0 - f(x0) * d / (f(x0+d) - f(x0)) } e = abs(x1-x0) x0 = x1 } return(list(x=x1, n=n))

26 Newton-Raphson Method > f = function(x){x^2-3} > Newton(1) $x [1] $n [1] 6 > Newton(0) $x [1] $n [1] 24

27 Exercises

28 Loops ## Create a sample matrix myma <- matrix(rnorm(500), 100, 5, dimnames=list(1:100, paste("c", 1:5, sep=""))) ## (1.1) Compute the mean of each row in myma by applying the mean function in a for loop myve_for <- NULL for(i in seq(along=myma[,1])) { myve_for <- c(myve_for, mean(as.numeric(myma[i, ]))) } myresult <- cbind(myma, mean_for=myve_for) myresult[1:4, ] ## (1.2) Compute the mean of each row in myma by applying the mean function in a while loop z <- 1 myve_while <- NULL while(z <= length(myma[,1])) { myve_while <- c(myve_while, mean(as.numeric(myma[z, ]))) z <- z + 1 } myresult <- cbind(myma, mean_for=myve_for, mean_while=myve_while) myresult[1:4, ] ## (1.3) How can one confirm that the results from both mean calculations are identical? ## (1.3) How can one confirm that the results from both mean calculations are identical? sum(myresult[,6]!= myresult[,7])

29 Loops ## (1.4) Compute the mean of each row in myma by applying the mean function in an apply loop myve_apply <- apply(myma, 1, mean) myresult <- cbind(myma, mean_for=myve_for, mean_while=myve_while, mean_apply=myve_apply) myresult[1:4, ] ## (1.5) Compute the row means of myma by taking advantage of the built-in looping behavior ## of the mean() function. This will require the transpose of myma and its conversion into a data frame. mymean <- mean(as.data.frame(t(myma))) myresult <- cbind(myma, mean_for=myve_for, mean_while=myve_while, mean_apply=myve_apply, mean_int=mymean) myresult[1:4, ] ## (1.6) How can one confirm that the values from all four mean calculations are identical? ## The unique() and length() functions can be used for this step. myq <- apply(myresult[,6:9], 1, function(x) length(unique(x))) sum(myq!= 1) ## (1.7) Replace one mean value in the last column by '0' and repeat the identity check in step (1.6) myresult[1 8] < 0 myresult[1,8] <- 0 myq <- apply(myresult[,6:9], 1, function(x) length(unique(x))) sum(myq!= 1)

30 Functions ## (2.2) Use the following code as basis to implement a function that allows the user ## to compute the mean for any combination of columns in a matrix or data frame. ## One argument of this function should specify the input data set and another should ## allow the selection of the columns by providing a grouping vector (factor). myma <- matrix(rnorm(100000), 10000, 10, dimnames=list(1:10000, paste("c", 1:10, sep=""))) mylist <- tapply(colnames(myma), c(1,1,1,2,2,2,3,3,4,4), list) names(mylist) <- sapply(mylist, paste, collapse="_") mymamean <- sapply(mylist, function(x) apply(myma[,x], 1, mean)) mymamean[1:4,] mymacomp <- function(myma=myma, group=c(1,1,1,2,2,2,3,3,4,4), myfct=mean) { mylist <- tapply(colnames(myma), group, list) names(mylist) <- sapply(mylist, paste, collapse="_") mymamean <- sapply(mylist, function(x) apply(myma[,x], 1, myfct)) return(mymamean) } mymacomp(myma=myma, group=c(1,1,1,2,2,2,3,3,4,4), myfct=mean)[1:4,]

31 Improving Speed Performance by Avoiding Loops ## (3.1) Implement a speed improved version of your previous function from step (2.2). ## Use the following code for its implementation. In this code the R loop over the ## data intensive dimension is avoided by using the rowmeans() function. mylist <- tapply(colnames(myma), c(1,1,1,2,2,2,3,3,4,4), list) mymamean <- sapply(mylist, function(x) rowmeans(myma[,x])) colnames(mymamean) <- sapply(mylist, paste, collapse="_") mymamean[1:4,] ## (3.2) Compare the speed performance of the implementation from step 2.2 with the ## speed improved version from step (3.1) using the system.time() function.

32 Looping over lists with lapply/sapply ## Create a sample list populated with character vectors of different lengths setlist <- lapply(11:30, function(x) sample(letters, x, replace=true)) names(setlist) <- paste("s", seq(along=setlist), setlist), sep="") ## (4.1) Compute the length for all pairwise intersects of the vectors stored in 'setlist'. ## The intersects can be determined with the '%in%' function like this: ## sum(setlist[[1]] %in% setlist[[2]]) setlist <- sapply(setlist, unique) olma <- sapply(names(setlist), function(x) sapply(names(setlist), function(y) sum(setlist[[x]] %in% setlist[[y]]))) olma ## (4.2) Plot the resulting intersect matrix as heat map ## The heatmap.2() function from the gplots library can be used for this. library("gplots") heatmap.2(olma, trace= "none", Colv= "none", Rowv= "none", dendrogram= "none", col=colorpanel(40, colorpanel(40 "darkred", "orange", "yellow"))