STATISTICS 579 R Tutorial : Programming in R

Transcription

1 Fall Conditional computation in R: STATISTICS 579 R Tutorial : Programming in R The basic control structure available in R for conditional computation is of the form if (cond) expr-1 else expr-2 where cond is an expression that evaluates to a logical value, expr-1 is an R expression that will be executed if the value of cond is TRUE; expr-2, is an R expression that will be executed if the value of cond is FALSE. Both expr-1 and expr-2 may be either simple R expressions or compound R expressions. A compound R expression consists of a group of simple R expressions enclosed in braces. Note that several R expressions may be entered on the same line as long as they are separated by semi-colons. Some examples are: > a=25;b=50 > if(a>b)c=a else c=b > c [1] 50 > gpa=3.5; sat=560 > if (gpa<3 sat<600){ + category="b" + score=gpa+.007*sat } else { + category="a" + score=gpa+.006*sat } > category [1] "B" > score [1] 7.42 Note carefully that if there is a newline just before the else clause, the if statement is taken to be complete, because the if statement without an else part, is a valid R statement. Note also that the operators && and are used to combine logical comparisons to make compound logical expressions. As noted before, the operators & and must be used to combine logical vectors. The functions all() and any() are also useful for making compound logical expressions by combining the components of their arguments using the && and the operators, respectively. > h [1] > h>10 [1] TRUE TRUE FALSE FALSE > h[1]>10&&h[2]>10&&h[3]>10&&h[4]>10 [1] FALSE > all(h>10) [1] FALSE > h[1]>10 h[2]>10 h[3]>10 h[4]>10 [1] TRUE > any(h>10) [1] TRUE 1

2 These two functions can be used on the results of more complex logical expressions: > a=rnorm(100,5,2) > any(a>9.5) [1] TRUE > all(a>.5) [1] FALSE > any(a<.5 a>9.5) [1] TRUE > a[a<.5 a>9.5] [1] > (1:100)[a<.5 a>9.5] [1] If the logical expression cond results in a vector of logical values, the ifelse() function is better suited for conditional evaluation. It is of the form ifelse(cond, expr-1, expr-2) and returns a value of the same shape as expr-1, containing elements from expr-1 or expr-2 depending on whether the corresponding elements of cond are TRUE or FALSE, respectively. > x=6:-4 > x [1] > ifelse(x>0,x,-x) [1] > ifelse(x>0,x,na) [1] NA NA NA NA NA > ifelse(x>0,sqrt(x),-sqrt(-x)) [1] [8] Warning messages: 1: NaNs produced in: sqrt(x) 2: NaNs produced in: sqrt(-x) 2. Looping in R: There are three kinds of looping constructs in R: the for loop, the while loop, and my favorite, the repeat loop. Three purposes that a loop is used in computation are: for repeating the same transformation (or computation) on every element of a data structure, say, an array or a matrix, for forming sums, such as we saw in the case of computational formulas for the sample variance, or summation of series expansions, and for implementing iterative methods. It is possible in R to avoid using loops in the first two instances because of the vectorizing capability of R. Thus we can take square roots of every element in a vector object or find the sample variance of a data in a vector object, without using a loop. In order to understand iterative methods, some background knowledge in numerical computing is useful. This topic will be covered in a later class where the use of the above looping constructs to program iterative methods will be discussed. 2

3 (a) for loops This type of loop construct is suitable when the sequence of values of a variable through which a loop is repeated, is known in advance. The general form of the statement is for(name in seq) expr where seq is a sequence values usually in a vector or a list, name is a name of an object usually a scalar, and expr is a simple or compound R expression. Each value of seq is assigned to the name in turn and the expression is evaluated. Thus the expression is evaluated repeatedly for different values of name, whether or not its value is used in the evaluation of the expression. The loop is terminated and control passed on to the next statement when the sequence of values is exhausted. Some simple examples are: > x=10:20 > x [1] > for(i in 1:11) x[i]=x[i]^2 > x [1] In the above example, the variable i is used for extracting successive elements of a vector using subscripting. As demonstrated below, the use of a loop is unnecessary in this example as the exponentiation operation is vectorized. > x=10:20 > x=x^2 > x [1] Similarly, a loop is unnecessary to calculate the difference of two vectors as the difference operator is vectorized. Note carefully in the following example that objects being created new, must be initialized before subscripts can be used to reference their elements in a for loop. In the example, diff1 is the new vector being formed element at a time: > a=rnorm(100) > a[1:10] [1] [7] > b=rnorm(100) > b[1:10] [1] [7] > diff1=rep(0,100) > for(i in 1:100) diff1[i]=a[i]-b[i] > diff1[1:10] [1] [7] Again, the difference is formed using vectorization, and in this case no initialization is necessary: > diff2=a-b > diff2[1:10] [1] [7]

4 As an example of the second type of computation itemized above, i.e., forming sums, consider the use of a for loop for the computation of sample variance using the twopass formula. Here loops are used for accumulating intermediate sums. > wtmean=0 > n=length(weight) > for( i in 1:n) wtmean=wtmean+weight[i] > wtmean=wtmean/n > wtvar=0 > for(i in 1:n) wtvar=wtvar+(weight[i]-wtmean)^2 > wtvar=wtvar/(n-1) > wtvar [1] > var(weight) [1] Recall that earlier we used the sum() function to perform the above computation. One may assume that for loops are necessary to accomplish many tasks involving selecting elements of matrices or arrays. While in many lower level languages this type of computation may require looping, in R these might be conveniently handled by subscripting methods described earlier. For example, two nested for loops are necessary for changing all negative values in a matrix to zero using looping: > mdata=c(1.2,3.5,4.7,1.8,-6.4,5.4,-1.9,2.7,3.4,-2.0,7.2,4.5) > m=matrix(mdata,3,4,byrow=t) > m [,1] [,2] [,3] [,4] [1,] [2,] [3,] > for(i in 1:dim(m)[1]) + for(j in 1:dim(m)[2]) + if(m[i,j]<0) m[i,j]=0 > m [,1] [,2] [,3] [,4] [1,] [2,] [3,] As seen earlier, the same result can be achieved in a single statement: > m=matrix(mdata,3,4,byrow=t) > m [,1] [,2] [,3] [,4] [1,] [2,] [3,] > m[m<0]=0 > m [,1] [,2] [,3] [,4] [1,] [2,] [3,]

5 A fancier use of subscripts to avoid looping is illustrated in the following example, where subscripts are used to shift the contents of a vector to the left by a position. The vector of standard normals is used again in this example: > a[1:10] [1] [7] > for(i in 1:100) a[i]=a[i+1] > a[1:10] [1] [7] > jj=1:100 > a[jj]=a[jj+1] > a[1:10] [1] [8] > a[95:100] [1] NA NA Below is an example where two nested for loops are used for computing the treatment totals of the weights for each of the levels of the factor feed. Note that the sequence in the second for loop here is a vector of character values. > chickwts > attach(chickwts) > levels(feed) [1] "casein" "horsebean" "linseed" "meatmeal" "soybean" "sunflower" > tots=rep(0,6) > names(tots)=levels(feed) > tots casein horsebean linseed meatmeal soybean sunflower > for(i in 1:71){ + for(diet in levels(feed)) + if(feed[i]==diet) tots[diet]=tots[diet]+weight[i] + } > tots casein horsebean linseed meatmeal soybean sunflower (b) while loops This kind of looping structure is suitable when the number of times the computations contained within the loop is repeated is not known in advance, and the termination of the loop is dependent on some other criteria. The general form of the while loop is: while(cond) expr The simple or compound R expression, expr, is repeatedly executed until the logical expression cond evaluates to a FALSE value. Then the loop is exited and control transfers to the next statement. The value of the cond logical expression must necessarily depend on computations carried out in expr. Below, an example previously used to illustrate the for loop, is redone using a while loop. Note that the loop counter j is incremented inside the loop. 5

6 > a=rnorm(100) > b=rnorm(100) > diff3=null > j=0 > while(j<100){ + j=j+1 + diff3[j]=a[j]-b[j] + } > diff3[1:10] [1] [7] In practice, a while loop is preferred when the cond expression is used for other purposes than just counting. It can be used, for example, to determine if a terminating condition such as that the error in a computed answer has decreased to be smaller than a prespecified tolerance level and therefore is acceptable. For example, the following loop accumulates a sum to compute exp(5) using the power series 1 + x + x2 2! + expansion: > i=0 > term=1 > sum=1 > x=5 > while(term>.0001){ + i=i+1 + term=x^i/factorial(i) + sum=sum+term + } > sum [1] > exp(5) [1] The loop is terminated when the value of the next term to be added to the series is less than or equal to Note that this loop will not work for negative vales of x.m Of course, if we knew that we need 21 terms in the series to achieve this accuracy of the result, we could have used the expression: > 1+sum(5^(1:20)/factorial(1:20)) [1] (c) repeat loops The repeat loop is similar to the while loop except that the condition for termination is tested inside the loop. This allows for more than a single condition to be checked and for these conditions to occur at different places in the loop. The general form of the repeat loop is: repeat expr where the expr is usually an R compound expression. The expression is evaluated repeatedly so that at least one break statement must be in the loop. The loop will be exited only when a given condition is satisfied. A break statement is of the form if(cond) break and any number of these statements may appear at different places in the loop with different cond logical expressions. 6

7 For example the while loop in the previous example may be rewritten as follows: > i=0 > sum=1 > x=5 > repeat{ + i=i+1 + term=x^i/factorial(i) + if(term<=.0001) break + sum=sum+term + } > sum [1] Thus there is not too much of a difference between a repeat and a while loop, unless there are more than a single test and exit points. Otherwise, the choice depends on how the user wants to organize the computations within the loop, and when the condition for exiting the loop is checked. 3. Creating and using R scripts If a sequence of R commands are to be executed a second time, it is cumbersome to enter them again one-command-at-a-time at the R prompt, especially if some commands are continued into several lines, as in the above example. The sequence can be editted into a script file and then sourced into R to be executed. The script file may also be re-editted to modify the code if necessary. These pieces of R code need not be R functions nor do they need not be made into R functions. The user selects the drop down menu option File New script to open a window for doing text editing. Once the set of R commands is entered as text, save the file in your current working directory (or another selected directory) using the menu option File Save as... while the editor window is selected. For example, enter the sequence of R commands i=0 sum=1 x=5 repeat{ i=i+1 term=x^i/factorial(i) sum=sum+term if(term<=.0001)break cat(" i = ",i, " Term = ", term, " Sum = ",sum,fill=t) } cat (" Final Value=", sum, fill=t) in the editor window and save it as log.r). In practice, a file name with a file type of.r, such as log.r), needs to be chosen to save scripts. R code saved in script file may be executed using the menu option File Source R code... and selecting the appropriate script file to run from the current working directory (or another selected directory). Any previously created scripts may be retrieved for further editing using the menu option File Open script... and selecting the appropriate file from the current working directory (or another selected directory). The editor window opened by default is the one set in the R function options(). The internal R editor is set-up as the default editor but the user may change it to something else: e.g. options(editor="notepad") 7

8 4. Evaluating Polynomials We used the infinite series expansion for exp(x) to compute exp(5.0) accurately. A bound for the truncation error of the series was used to determine the number of terms necessary to be summed to compute exp(5.0) to a required accuracy. If the same series is used to compute exp( 9.1), for example, although a certain number of terms of the series should be sufficient to obtain a required accuracy theoretically, the computed value may not have enough correct significant digits. For negative values of x, the alternate terms in the series are of opposite signs and consequently loss of significant digits will occur as the cumulative sum is formed. Loss of significant digits takes place when two numbers of similar magnitudes of the same sign are subtracted. One way to avoid this when alternating terms of a series are of opposite signs, is to form the differences before summing them up. For example in summing the series a 0 a 1 x + a 2 x 2 a 3 x 3 + form the successive differences a 0 a 1 x, a 2 x 2 a 3 x 3 first. A better way to compute exp( x) is to use the relation exp( x) = 1/ exp(x). In practice infinite series are hardly used for the purpose of calculating functions. Instead, various function approximation methods are utilized to derive finite series approximations. A polynomial f(x) of degree n is a function of the form f(x) = a 0 + a 1 x + a 2 x a n x n (1) This form, called the power form, is the standard method of representing polynomial functions for mathematical purposes. However, if polynomials are to be evaluated in numerical computations, using other representations of f(x), one of which is discussed below, often leads to increased accuracy. The reason for this is that these representations are morenumerically stable than the power form. One such representation, often called Horner s rule, f(x) of (1) is re-expressed in the form Consider the evaluation of f(x) = a 0 + (a 1 + (a 2... (a n 1 + a n x)x...)x. (2) f(x) = 7 + 3x + 4x 2 9x 3 + 5x 4 + 2x 5. An expression for evaluating f(x) using Horner s rule is (3.0 + (4.0 + ( ( x) x) x) x) x which requires only 5 multiplications, which is 10 multiplications less than evaluating f(x) using the expression x x 2 9.0x 3 + where x 2 is counted as a multiplication. This representation can be coded in the following form in R: sum= a[n] for (i in n-1:1){ sum=sum*x+a[i] } cat(" Series sum = ",sum,fill=t) 8

9 where a is a vector containing the coefficients a 1, a 2,..., a n A finite series approximation for cos x is given by cos x = a 0 + a 2 x 2 + a 4 x 4 + a 6 x 6 + a 8 x 6 + a 10 x 10 + ɛ(x) where 0 x π/2 and (ɛ(x) , and the constants are a 2 = , a 4 = , a 6 = , a 8 = , a 10 = The following script in R uses this approximation to compute cos (1.234) x=1.234 a=c(1, , , , , ) sum=a[6] for (i in 5:1){ sum=sum*x^2+a[i] } cat(" x=", x, " approx cosine = ", round(sum,8), " true value = ", round(cos(x),8),fill=t) Executing this code gave the result x= approx cosine = true value =