Chapter 4: apply Functions (2024)

A Language, not a Letter: Learning Statistics in R

Intro
R-programming
- Chapter 1: Introduction
- Chapter 2: Indexing
- Chapter 4: Apply Family
- Chapter 5: Plyr Package
- Chapter 6: Vectorizing
- Chapter 9: Tidyr Package
Plotting
- Chapter 10: GGPlot1: Basics
Regression
- Chapter 13: Ploting Interactions
- Chapter 14: Moderation/Mediation
- Chapter 15: Moderated-Mediation
- Chapter 16: MultiLevel Models
- Chapter 17: Mixed Models
- Chapter 18: Mixed Assumptions Testing
ANOVA
- Chapter 20: Between-Subjects
Advanced
- Chapter 22: Correlations
- Chapter 23: ARIMA
- Chapter 24: Decision Trees
- Chapter 25: Signal Detection
Apps
- Chapter 26: Intro to Shiny
- Chapter 27: ANOVA Variance

Download Rmd

Erin Sovansky Winter

Apply functions are a family of functions in base R which allow you to repetitively perform an action on multiple chunks of data. An apply function is essentially a loop, but run faster than loops and often require less code.

The apply functions that this chapter will address are apply, lapply, sapply, vapply, tapply, and mapply. There are so many different apply functions because they are meant to operate on different types of data.

First, let’s go over the basic apply function. You can use the help section to get a description of this function.

?apply

the apply function looks like this: apply(X, MARGIN, FUN).

X is an array or matrix (this is the data that you will be performing the function on)
Margin specifies whether you want to apply the function across rows (1) or columns (2)
FUN is the function you want to use

2.1 apply examples

my.matrx is a matrix with 1-10 in column 1, 11-20 in column 2, and 21-30 in column 3. my.matrx will be used to show some of the basic uses for the apply function.

my.matrx <- matrix(c(1:10, 11:20, 21:30), nrow = 10, ncol = 3)my.matrx

## [,1] [,2] [,3]## [1,] 1 11 21## [2,] 2 12 22## [3,] 3 13 23## [4,] 4 14 24## [5,] 5 15 25## [6,] 6 16 26## [7,] 7 17 27## [8,] 8 18 28## [9,] 9 19 29## [10,] 10 20 30

2.1.1 Example 1: Using apply to find row sums

What if I wanted to summarize the data in matrix m by finding the sum of each row? The arguments are X = m, MARGIN = 1 (for row), and FUN = sum

apply(my.matrx, 1, sum)

## [1] 33 36 39 42 45 48 51 54 57 60

The apply function returned a vector containing the sums for each row.

2.1.2 Example 2: Creating a function in the arguments

What if I wanted to be able to find how many datapoints (n) are in each column of m? I can use the length function to do this. Because we are using columns, MARGIN = 2.

apply(my.matrx, 2, length)

## [1] 10 10 10

What if instead, I wanted to find n-1 for each column? There isn’t a function in R to do this automatically, so I can create my own function. If the function is simple, you can create it right inside the arguments for apply. In the arguments I created a function that returns length - 1.

apply(my.matrx, 2, function (x) length(x)-1)

## [1] 9 9 9

As you can see, the function correctly returned a vector of n-1 for each column.

2.1.3 Example 3: Using a function defined outside of apply

If you don’t want to write a function inside of the arguments, you can define the function outside of apply, and then use that function in apply later. This may be useful if you want to have the function available to use later. In this example, a function to find standard error was created, then passed into an apply function.

st.err <- function(x){ sd(x)/sqrt(length(x))}apply(my.matrx,2, st.err)

## [1] 0.9574271 0.9574271 0.9574271

2.1.4 Example 4: Transforming data

Now for something a little different. In the previous examples, apply was used to summarize over a row or column. It can also be used to repeat a function on cells within a matrix. In this example, the apply function is used to transform the values in each cell. Pay attention to the MARGIN argument. If you set the MARGIN to 1:2 it will have the function operate on each cell.

my.matrx2 <- apply(my.matrx,1:2, function(x) x+3)my.matrx2

## [,1] [,2] [,3]## [1,] 4 14 24## [2,] 5 15 25## [3,] 6 16 26## [4,] 7 17 27## [5,] 8 18 28## [6,] 9 19 29## [7,] 10 20 30## [8,] 11 21 31## [9,] 12 22 32## [10,] 13 23 33

2.1.5 Example 5: Vectors?

The previous examples showed several ways to use the apply function on a matrix. But what if I wanted to loop through a vector instead? Will the apply function work?

vec <- c(1:10)vec

## [1] 1 2 3 4 5 6 7 8 9 10

apply(vec, 1, sum)

If you run this function it will return the error: Error in apply(v, 1, sum) : dim(X) must have a positive length. As you can see, this didn’t work because apply was expecting the data to have at least two dimensions. If your data is a vector you need to use lapply, sapply, or vapply instead.

lapply, sapply, and vapply are all functions that will loop a function through data in a list or vector. First, try looking up lapply in the help section to see a description of all three function.

?lapply

Here are the agruments for the three functions:

lapply(X, FUN, …)
sapply(X, FUN, …, simplify = TRUE, USE.NAMES = TRUE)
vapply(X, FUN, FUN.VALUE, …, USE.NAMES = TRUE)

In this case, X is a vector or list, and FUN is the function you want to use. sapply and vapply have extra arguments, but most of them have default values, so you don’t need to worry about them. However, vapply requires another agrument called FUN.VALUE, which we will look at later.

3.0.1 Example 1: Getting started with lapply

Earlier, we created the vector v. Let’s use that vector to test out the lapply function.

lapply(vec, sum)

## [[1]]## [1] 1## ## [[2]]## [1] 2## ## [[3]]## [1] 3## ## [[4]]## [1] 4## ## [[5]]## [1] 5## ## [[6]]## [1] 6## ## [[7]]## [1] 7## ## [[8]]## [1] 8## ## [[9]]## [1] 9## ## [[10]]## [1] 10

This function didn’t add up the values like we may have expected it to. This is because lapply applies treats the vector like a list, and applies the function to each point in the vector.

Let’s try using a list instead

A<-c(1:9)B<-c(1:12)C<-c(1:15)my.lst<-list(A,B,C)lapply(my.lst, sum)

## [[1]]## [1] 45## ## [[2]]## [1] 78## ## [[3]]## [1] 120

This time, the lapply function seemed to work better. The function summed each vector in the list and returned a list of the 3 sums.

3.0.2 Example 2: sapply

sapply works just like lapply, but will simplify the output if possible. This means that instead of returning a list like lapply, it will return a vector instead if the data is simplifiable.

sapply(vec, sum)

## [1] 1 2 3 4 5 6 7 8 9 10

sapply(my.lst, sum)

## [1] 45 78 120

See how these two examples gave the same answers, but returned a vector instead?

3.0.3 Example 3: vapply

vapply is similar to sapply, but it requires you to specify what type of data you are expecting the arguments for vapply are vapply(X, FUN, FUN.VALUE). FUN.VALUE is where you specify the type of data you are expecting. I am expecting each item in the list to return a single numeric value, so FUN.VALUE = numeric(1).

vapply(vec, sum, numeric(1))

## [1] 1 2 3 4 5 6 7 8 9 10

vapply(my.lst, sum, numeric(1))

## [1] 45 78 120

If your function were to return more than one numeric value, FUN.VALUE = numeric(1) will cause the function to return an error. This could be useful if you are expecting only one result per subject.

#vapply(my.lst, function(x) x+2, numeric(1))

3.0.4 Example 4: Transforming data with sapply

Like apply, these functions can also be used for transforming data inside the list

my.lst2 <- sapply(my.lst, function(x) x*2)my.lst2

## [[1]]## [1] 2 4 6 8 10 12 14 16 18## ## [[2]]## [1] 2 4 6 8 10 12 14 16 18 20 22 24## ## [[3]]## [1] 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30

3.0.5 Which function should I use, lapply, sapply, or vapply?

If you are trying to decide which of these three functions to use, because it is the simplest, I would suggest to use sapply if possible. If you do not want your results to be simplified to a vector, lapply should be used. If you want to specify the type of result you are expecting, use vapply.

Sometimes you may want to perform the apply function on some data, but have it separated by factor. In that case, you should use tapply. Let’s take a look at the information for tapply.

?tapply

The arguments for tapply are tapply(X, INDEX, FUN). The only new argument is INDEX, which is the factor you want to use to separate the data.

4.0.1 Example 1: Means split by condition

First, let’s create data with an factor for indexing. Dataset t will be created by adding a factor to matrix m and converting it to a dataframe.

tdata <- as.data.frame(cbind(c(1,1,1,1,1,2,2,2,2,2), my.matrx))colnames(tdata)

## [1] "V1" "V2" "V3" "V4"

Now let’s use column 1 as the index and find the mean of column 2

tapply(tdata$V2, tdata$V1, mean)

## 1 2 ## 3 8

4.0.2 Example 2: Combining functions

You can use tapply to do some quick summary statistics on a variable split by condition. In this example, I created a function that returns a vector ofboth the mean and standard deviation. You can create a function like this for any apply function, not just tapply.

summary <- tapply(tdata$V2, tdata$V1, function(x) c(mean(x), sd(x)))summary

## $`1`## [1] 3.000000 1.581139## ## $`2`## [1] 8.000000 1.581139

the last apply function I will cover is mapply.

?mapply

the arguments for mapply are mapply(FUN, …, MoreArgs = NULL, SIMPLIFY = TRUE, USE.NAMES = TRUE). First you list the function, followed by the vectors you are using the rest of the arguments have default values so they don’t need to be changed for now. When you have a function that takes 2 arguments, the first vector goes into the first argument and the second vector goes into the second argument.

5.0.1 Example 1: Understanding mapply

In this example, 1:9 is specifying the value to repeat, and 9:1 is specifying how many times to repeat. This order is based on the order of arguments in the rep function itself.

mapply(rep, 1:9, 9:1)

## [[1]]## [1] 1 1 1 1 1 1 1 1 1## ## [[2]]## [1] 2 2 2 2 2 2 2 2## ## [[3]]## [1] 3 3 3 3 3 3 3## ## [[4]]## [1] 4 4 4 4 4 4## ## [[5]]## [1] 5 5 5 5 5## ## [[6]]## [1] 6 6 6 6## ## [[7]]## [1] 7 7 7## ## [[8]]## [1] 8 8## ## [[9]]## [1] 9

5.0.2 Example 2: Creating a new variable

Another use for mapply would be to create a new variable. For example, using dataset t, I could divide one column by another column to create a new value. This would be useful for creating a ratio of two variables as shown in the example below.

tdata$V5 <- mapply(function(x, y) x/y, tdata$V2, tdata$V4)tdata$V5

## [1] 0.04761905 0.09090909 0.13043478 0.16666667 0.20000000 0.23076923## [7] 0.25925926 0.28571429 0.31034483 0.33333333

5.0.3 Example 3: Saving data into a premade vector

When using an apply family function to create a new variable, one option is to create a new vector ahead of time with the size of the vector pre-allocated. I created a numeric vector of length 10 using the vector function. The arguments for the vector function are vector(mode, length). Inside mapply I created a function to multiple two variables together. The results of the mapply function are then saved into the vector.

new.vec <- vector(mode = "numeric", length = 10)new.vec <- mapply(function(x, y) x*y, tdata$V3, tdata$V4)new.vec

## [1] 231 264 299 336 375 416 459 504 551 600

This last section will be a few examples of using apply functions on real data.This section will make use of the MASS package, which is a collection of publicly available datasets. Please install MASS if you do not already have it. If you do not have MASS installed, you can uncomment the code below.

#install.packages("MASS")library(MASS)

load the state dataset. It contains information about all 50 states

data(state)

Let’s look at the data we will be using. We will be using the state.x77 dataset

head(state.x77)

## Population Income Illiteracy Life Exp Murder HS Grad Frost## Alabama 3615 3624 2.1 69.05 15.1 41.3 20## Alaska 365 6315 1.5 69.31 11.3 66.7 152## Arizona 2212 4530 1.8 70.55 7.8 58.1 15## Arkansas 2110 3378 1.9 70.66 10.1 39.9 65## California 21198 5114 1.1 71.71 10.3 62.6 20## Colorado 2541 4884 0.7 72.06 6.8 63.9 166## Area## Alabama 50708## Alaska 566432## Arizona 113417## Arkansas 51945## California 156361## Colorado 103766

str(state.x77)

## num [1:50, 1:8] 3615 365 2212 2110 21198 ...## - attr(*, "dimnames")=List of 2## ..$ : chr [1:50] "Alabama" "Alaska" "Arizona" "Arkansas" ...## ..$ : chr [1:8] "Population" "Income" "Illiteracy" "Life Exp" ...

All the data in the dataset happens to be numeric, which is necessary when the function inside the apply function requires numeric data.

6.0.1 Example 1: using apply to get summary data

You can use apply to find measures of central tendency and dispersion

apply(state.x77, 2, mean)

## Population Income Illiteracy Life Exp Murder HS Grad ## 4246.4200 4435.8000 1.1700 70.8786 7.3780 53.1080 ## Frost Area ## 104.4600 70735.8800

apply(state.x77, 2, median)

## Population Income Illiteracy Life Exp Murder HS Grad ## 2838.500 4519.000 0.950 70.675 6.850 53.250 ## Frost Area ## 114.500 54277.000

apply(state.x77, 2, sd)

## Population Income Illiteracy Life Exp Murder ## 4.464491e+03 6.144699e+02 6.095331e-01 1.342394e+00 3.691540e+00 ## HS Grad Frost Area ## 8.076998e+00 5.198085e+01 8.532730e+04

6.0.2 Example 2: Saving the results of apply

In this, I created one function that gives the mean and SD, and another that give min, median, and max. Then I saved them as objects that could be used later.

state.summary<- apply(state.x77, 2, function(x) c(mean(x), sd(x))) state.summary

## Population Income Illiteracy Life Exp Murder HS Grad Frost## [1,] 4246.420 4435.8000 1.1700000 70.878600 7.37800 53.108000 104.46000## [2,] 4464.491 614.4699 0.6095331 1.342394 3.69154 8.076998 51.98085## Area## [1,] 70735.88## [2,] 85327.30

state.range <- apply(state.x77, 2, function(x) c(min(x), median(x), max(x)))state.range

## Population Income Illiteracy Life Exp Murder HS Grad Frost Area## [1,] 365.0 3098 0.50 67.960 1.40 37.80 0.0 1049## [2,] 2838.5 4519 0.95 70.675 6.85 53.25 114.5 54277## [3,] 21198.0 6315 2.80 73.600 15.10 67.30 188.0 566432

6.0.3 Example 3: Using mapply to compute a new variable

In this example, I want to find the population density for each state. In order to do this, I want to divide population by area. state.area and state.x77 are not from the same dataset, but that is fine as long as the vectors are the same length and the data is in the same order. Both vectors are alphabetically by state, so mapply can be used.

population <- state.x77[1:50]area <- state.areapop.dens <- mapply(function(x, y) x/y, population, area)pop.dens

## [1] 0.070045922 0.000618899 0.019419010 0.039733353 0.133578671## [6] 0.024374802 0.618886005 0.281477880 0.141342213 0.083752293## [11] 0.134573643 0.009729885 0.198528369 0.146399934 0.050826079## [16] 0.027715647 0.083847011 0.078437030 0.031853078 0.389713529## [21] 0.704129829 0.156503367 0.046640815 0.049061112 0.068406854## [26] 0.005070070 0.019993008 0.005337434 0.087274291 0.935809086## [31] 0.009402791 0.364611909 0.103468604 0.009014364 0.260419194## [36] 0.038830647 0.023551005 0.261619571 0.766886326 0.090677830## [41] 0.008838761 0.098783259 0.045773344 0.014166941 0.049120616## [46] 0.122038466 0.052190873 0.074397254 0.081721694 0.003840105

6.0.4 Example 4: Using tapply to explore population by region

In this example, I want to find out some information about the population of states split by region. state.region is a factor with four levels: Northeast, South, North Central, and West. For each region, I want the minimum, median, and maximum populations.

region.info <- tapply(population, state.region, function(x) c(min(x), median(x), max(x)))region.info

## $Northeast## [1] 472 3100 18076## ## $South## [1] 579.0 3710.5 12237.0## ## $`North Central`## [1] 637 4255 11197## ## $West## [1] 365 1144 21198

Here are some sources I used to help me create this chapter:

Datacamp tutorial on apply functions: https://www.datacamp.com/community/tutorials/r-tutorial-apply-family

r-bloggers: Using apply, sapply, and lapply in R: https://www.r-bloggers.com/using-apply-sapply-lapply-in-r/

stackoverflow: Why is vapply safer than sapply?: http://stackoverflow.com/questions/12339650/why-is-vapply-safer-than-sapply

LS0tDQp0aXRsZTogJ0NoYXB0ZXIgNDogYXBwbHkgRnVuY3Rpb25zJw0KYXV0aG9yOiAiRXJpbiBTb3ZhbnNreSBXaW50ZXIiDQpvdXRwdXQ6DQogIGh0bWxfZG9jdW1lbnQ6DQogICAgdGhlbWU6IGNlcnVsZWFuDQogICAgaGlnaGxpZ2h0OiB0ZXh0bWF0ZQ0KICAgIGZvbnRzaXplOiA4cHQNCiAgICB0b2M6IHRydWUNCiAgICBudW1iZXJfc2VjdGlvbnM6IHRydWUNCiAgICBjb2RlX2Rvd25sb2FkOiB0cnVlDQogICAgdG9jX2Zsb2F0Og0KICAgICAgY29sbGFwc2VkOiBmYWxzZQ0KLS0tDQoNCmBgYHtyIHNldHVwLCBpbmNsdWRlPUZBTFNFfQ0Ka25pdHI6Om9wdHNfY2h1bmskc2V0KGVjaG8gPSBUUlVFKQ0KYGBgDQoNCiMgIFdoYXQgYXJlIGFwcGx5IGZ1bmN0aW9ucz8NCkFwcGx5IGZ1bmN0aW9ucyBhcmUgYSBmYW1pbHkgb2YgZnVuY3Rpb25zIGluIGJhc2UgUiB3aGljaCBhbGxvdyB5b3UgdG8gcmVwZXRpdGl2ZWx5IHBlcmZvcm0gYW4NCmFjdGlvbiBvbiBtdWx0aXBsZSBjaHVua3Mgb2YgZGF0YS4gQW4gYXBwbHkgZnVuY3Rpb24gaXMgZXNzZW50aWFsbHkgYSBsb29wLCBidXQgcnVuIGZhc3RlciB0aGFuIA0KbG9vcHMgYW5kIG9mdGVuIHJlcXVpcmUgbGVzcyBjb2RlLiANCg0KVGhlIGFwcGx5IGZ1bmN0aW9ucyB0aGF0IHRoaXMgY2hhcHRlciB3aWxsIGFkZHJlc3MgYXJlIGFwcGx5LCBsYXBwbHksIHNhcHBseSwgdmFwcGx5LCB0YXBwbHksIGFuZA0KbWFwcGx5LiBUaGVyZSBhcmUgc28gbWFueSBkaWZmZXJlbnQgYXBwbHkgZnVuY3Rpb25zIGJlY2F1c2UgdGhleSBhcmUgbWVhbnQgdG8gb3BlcmF0ZSBvbiBkaWZmZXJlbnQNCnR5cGVzIG9mIGRhdGEuIA0KDQojICBUaGUgYXBwbHkgZnVuY3Rpb24NCkZpcnN0LCBsZXQncyBnbyBvdmVyIHRoZSBiYXNpYyBhcHBseSBmdW5jdGlvbi4gWW91IGNhbiB1c2UgdGhlIGhlbHAgc2VjdGlvbiB0byBnZXQgYSBkZXNjcmlwdGlvbg0Kb2YgdGhpcyBmdW5jdGlvbi4NCmBgYHtyLCBldmFsPUZBTFNFfQ0KP2FwcGx5DQpgYGANCnRoZSBhcHBseSBmdW5jdGlvbiBsb29rcyBsaWtlIHRoaXM6IGFwcGx5KFgsIE1BUkdJTiwgRlVOKS4gDQoNCiogWCBpcyBhbiBhcnJheSBvciBtYXRyaXggKHRoaXMgaXMgdGhlIGRhdGEgdGhhdCB5b3Ugd2lsbCBiZSBwZXJmb3JtaW5nIHRoZSBmdW5jdGlvbiBvbikNCiogTWFyZ2luIHNwZWNpZmllcyB3aGV0aGVyIHlvdSB3YW50IHRvIGFwcGx5IHRoZSBmdW5jdGlvbiBhY3Jvc3Mgcm93cyAoMSkgb3IgY29sdW1ucyAoMikNCiogRlVOIGlzIHRoZSBmdW5jdGlvbiB5b3Ugd2FudCB0byB1c2UNCg0KIyMgYXBwbHkgZXhhbXBsZXMNCm15Lm1hdHJ4IGlzIGEgbWF0cml4IHdpdGggMS0xMCBpbiBjb2x1bW4gMSwgMTEtMjAgaW4gY29sdW1uIDIsIGFuZCAyMS0zMCBpbiBjb2x1bW4gMy4gDQpteS5tYXRyeCB3aWxsIGJlIHVzZWQgdG8gc2hvdyBzb21lIG9mIHRoZSBiYXNpYyB1c2VzIGZvciB0aGUgYXBwbHkgZnVuY3Rpb24uDQpgYGB7cn0NCm15Lm1hdHJ4IDwtIG1hdHJpeChjKDE6MTAsIDExOjIwLCAyMTozMCksIG5yb3cgPSAxMCwgbmNvbCA9IDMpDQpteS5tYXRyeA0KYGBgDQoNCiMjIyBFeGFtcGxlIDE6IFVzaW5nIGFwcGx5IHRvIGZpbmQgcm93IHN1bXMNCldoYXQgaWYgSSB3YW50ZWQgdG8gc3VtbWFyaXplIHRoZSBkYXRhIGluIG1hdHJpeCBtIGJ5IGZpbmRpbmcgdGhlIHN1bSBvZiBlYWNoIHJvdz8gVGhlIGFyZ3VtZW50cyANCmFyZSBYID0gbSwgTUFSR0lOID0gMSAoZm9yIHJvdyksIGFuZCBGVU4gPSBzdW0NCg0KYGBge3J9DQphcHBseShteS5tYXRyeCwgMSwgc3VtKQ0KYGBgDQpUaGUgYXBwbHkgZnVuY3Rpb24gcmV0dXJuZWQgYSB2ZWN0b3IgY29udGFpbmluZyB0aGUgc3VtcyBmb3IgZWFjaCByb3cuDQoNCiMjIyBFeGFtcGxlIDI6IENyZWF0aW5nIGEgZnVuY3Rpb24gaW4gdGhlIGFyZ3VtZW50cw0KV2hhdCBpZiBJIHdhbnRlZCB0byBiZSBhYmxlIHRvIGZpbmQgaG93IG1hbnkgZGF0YXBvaW50cyAobikgYXJlIGluIGVhY2ggY29sdW1uIG9mIG0/IEkgY2FuIHVzZSANCnRoZSBsZW5ndGggZnVuY3Rpb24gdG8gZG8gdGhpcy4gQmVjYXVzZSB3ZSBhcmUgdXNpbmcgY29sdW1ucywgTUFSR0lOID0gMi4NCmBgYHtyfQ0KYXBwbHkobXkubWF0cngsIDIsIGxlbmd0aCkNCmBgYA0KV2hhdCBpZiBpbnN0ZWFkLCBJIHdhbnRlZCB0byBmaW5kIG4tMSBmb3IgZWFjaCBjb2x1bW4/IFRoZXJlIGlzbid0IGEgZnVuY3Rpb24gaW4gUiB0byBkbyB0aGlzDQphdXRvbWF0aWNhbGx5LCBzbyBJIGNhbiBjcmVhdGUgbXkgb3duIGZ1bmN0aW9uLiBJZiB0aGUgZnVuY3Rpb24gaXMgc2ltcGxlLCB5b3UgY2FuIGNyZWF0ZSBpdA0KcmlnaHQgaW5zaWRlIHRoZSBhcmd1bWVudHMgZm9yIGFwcGx5LiBJbiB0aGUgYXJndW1lbnRzIEkgY3JlYXRlZCBhIGZ1bmN0aW9uIHRoYXQgcmV0dXJucw0KbGVuZ3RoIC0gMS4NCmBgYHtyfQ0KYXBwbHkobXkubWF0cngsIDIsIGZ1bmN0aW9uICh4KSBsZW5ndGgoeCktMSkNCmBgYA0KQXMgeW91IGNhbiBzZWUsIHRoZSBmdW5jdGlvbiBjb3JyZWN0bHkgcmV0dXJuZWQgYSB2ZWN0b3Igb2Ygbi0xIGZvciBlYWNoIGNvbHVtbi4NCiANCiMjIyBFeGFtcGxlIDM6IFVzaW5nIGEgZnVuY3Rpb24gZGVmaW5lZCBvdXRzaWRlIG9mIGFwcGx5DQpJZiB5b3UgZG9uJ3Qgd2FudCB0byB3cml0ZSBhIGZ1bmN0aW9uIGluc2lkZSBvZiB0aGUgYXJndW1lbnRzLCB5b3UgY2FuIGRlZmluZSB0aGUgZnVuY3Rpb24gDQpvdXRzaWRlIG9mIGFwcGx5LCBhbmQgdGhlbiB1c2UgdGhhdCBmdW5jdGlvbiBpbiBhcHBseSBsYXRlci4gVGhpcyBtYXkgYmUgdXNlZnVsIGlmIHlvdSB3YW50IHRvIA0KaGF2ZSB0aGUgZnVuY3Rpb24gYXZhaWxhYmxlIHRvIHVzZSBsYXRlci4gSW4gdGhpcyBleGFtcGxlLCBhIGZ1bmN0aW9uIHRvIGZpbmQgc3RhbmRhcmQgZXJyb3Igd2FzDQpjcmVhdGVkLCB0aGVuIHBhc3NlZCBpbnRvIGFuIGFwcGx5IGZ1bmN0aW9uLg0KYGBge3J9DQpzdC5lcnIgPC0gZnVuY3Rpb24oeCl7DQogIHNkKHgpL3NxcnQobGVuZ3RoKHgpKQ0KfQ0KYXBwbHkobXkubWF0cngsMiwgc3QuZXJyKQ0KYGBgDQoNCiMjIyBFeGFtcGxlIDQ6IFRyYW5zZm9ybWluZyBkYXRhDQpOb3cgZm9yIHNvbWV0aGluZyBhIGxpdHRsZSBkaWZmZXJlbnQuIEluIHRoZSBwcmV2aW91cyBleGFtcGxlcywgYXBwbHkgd2FzIHVzZWQgdG8gc3VtbWFyaXplDQpvdmVyIGEgcm93IG9yIGNvbHVtbi4gSXQgY2FuIGFsc28gYmUgdXNlZCB0byByZXBlYXQgYSBmdW5jdGlvbiBvbiBjZWxscyB3aXRoaW4gYSBtYXRyaXguIEluIHRoaXMNCmV4YW1wbGUsIHRoZSBhcHBseSBmdW5jdGlvbiBpcyB1c2VkIHRvIHRyYW5zZm9ybSB0aGUgdmFsdWVzIGluIGVhY2ggY2VsbC4gUGF5IGF0dGVudGlvbiB0byB0aGUNCk1BUkdJTiBhcmd1bWVudC4gSWYgeW91IHNldCB0aGUgTUFSR0lOIHRvIDE6MiBpdCB3aWxsIGhhdmUgdGhlIGZ1bmN0aW9uIG9wZXJhdGUgb24gZWFjaCBjZWxsLg0KYGBge3J9DQpteS5tYXRyeDIgPC0gYXBwbHkobXkubWF0cngsMToyLCBmdW5jdGlvbih4KSB4KzMpDQpteS5tYXRyeDINCmBgYA0KDQojIyMgRXhhbXBsZSA1OiBWZWN0b3JzPw0KVGhlIHByZXZpb3VzIGV4YW1wbGVzIHNob3dlZCBzZXZlcmFsIHdheXMgdG8gdXNlIHRoZSBhcHBseSBmdW5jdGlvbiBvbiBhIG1hdHJpeC4gQnV0IHdoYXQgaWYgSSANCndhbnRlZCB0byBsb29wIHRocm91Z2ggYSB2ZWN0b3IgaW5zdGVhZD8gV2lsbCB0aGUgYXBwbHkgZnVuY3Rpb24gd29yaz8NCg0KYGBge3IsIH0NCnZlYyA8LSBjKDE6MTApDQp2ZWMNCmBgYA0KYGBge3IsIGV2YWw9RkFMU0V9DQphcHBseSh2ZWMsIDEsIHN1bSkNCmBgYA0KSWYgeW91IHJ1biB0aGlzIGZ1bmN0aW9uIGl0IHdpbGwgcmV0dXJuIHRoZSBlcnJvcjogRXJyb3IgaW4gYXBwbHkodiwgMSwgc3VtKSA6IGRpbShYKSBtdXN0IGhhdmUgYSBwb3NpdGl2ZSBsZW5ndGguIA0KQXMgeW91IGNhbiBzZWUsIHRoaXMgZGlkbid0IHdvcmsgYmVjYXVzZSBhcHBseSB3YXMgZXhwZWN0aW5nIHRoZSBkYXRhIHRvIGhhdmUgYXQgbGVhc3QgdHdvIGRpbWVuc2lvbnMuIElmIHlvdXIgZGF0YSBpcyBhIHZlY3RvciB5b3UgbmVlZCB0byB1c2UgbGFwcGx5LCBzYXBwbHksIG9yIHZhcHBseSBpbnN0ZWFkLg0KDQojIGxhcHBseSwgc2FwcGx5LCBhbmQgdmFwcGx5DQpsYXBwbHksIHNhcHBseSwgYW5kIHZhcHBseSBhcmUgYWxsIGZ1bmN0aW9ucyB0aGF0IHdpbGwgbG9vcCBhIGZ1bmN0aW9uIHRocm91Z2ggZGF0YSBpbiBhIGxpc3Qgb3INCnZlY3Rvci4gRmlyc3QsIHRyeSBsb29raW5nIHVwIGxhcHBseSBpbiB0aGUgaGVscCBzZWN0aW9uIHRvIHNlZSBhIGRlc2NyaXB0aW9uIG9mIGFsbCB0aHJlZSANCmZ1bmN0aW9uLg0KDQpgYGB7ciwgZXZhbD1GQUxTRX0NCj9sYXBwbHkNCmBgYA0KDQpIZXJlIGFyZSB0aGUgYWdydW1lbnRzIGZvciB0aGUgdGhyZWUgZnVuY3Rpb25zOg0KDQoqIGxhcHBseShYLCBGVU4sIC4uLikNCiogc2FwcGx5KFgsIEZVTiwgLi4uLCBzaW1wbGlmeSA9IFRSVUUsIFVTRS5OQU1FUyA9IFRSVUUpDQoqIHZhcHBseShYLCBGVU4sIEZVTi5WQUxVRSwgLi4uLCBVU0UuTkFNRVMgPSBUUlVFKQ0KDQpJbiB0aGlzIGNhc2UsIFggaXMgYSB2ZWN0b3Igb3IgbGlzdCwgYW5kIEZVTiBpcyB0aGUgZnVuY3Rpb24geW91IHdhbnQgdG8gdXNlLiBzYXBwbHkgYW5kIHZhcHBseSBoYXZlIGV4dHJhIGFyZ3VtZW50cywgYnV0IG1vc3Qgb2YgdGhlbSBoYXZlIGRlZmF1bHQgdmFsdWVzLCBzbyB5b3UgZG9uJ3QgbmVlZCB0byB3b3JyeSBhYm91dA0KdGhlbS4gSG93ZXZlciwgdmFwcGx5IHJlcXVpcmVzIGFub3RoZXIgYWdydW1lbnQgY2FsbGVkIEZVTi5WQUxVRSwgd2hpY2ggd2Ugd2lsbCBsb29rIGF0IGxhdGVyLg0KDQojIyMgRXhhbXBsZSAxOiBHZXR0aW5nIHN0YXJ0ZWQgd2l0aCBsYXBwbHkNCkVhcmxpZXIsIHdlIGNyZWF0ZWQgdGhlIHZlY3RvciB2LiBMZXQncyB1c2UgdGhhdCB2ZWN0b3IgdG8gdGVzdCBvdXQgdGhlIGxhcHBseSBmdW5jdGlvbi4NCmBgYHtyfQ0KbGFwcGx5KHZlYywgc3VtKQ0KYGBgDQpUaGlzIGZ1bmN0aW9uIGRpZG4ndCBhZGQgdXAgdGhlIHZhbHVlcyBsaWtlIHdlIG1heSBoYXZlIGV4cGVjdGVkIGl0IHRvLiBUaGlzIGlzIGJlY2F1c2UgbGFwcGx5DQphcHBsaWVzIHRyZWF0cyB0aGUgdmVjdG9yIGxpa2UgYSBsaXN0LCBhbmQgYXBwbGllcyB0aGUgZnVuY3Rpb24gdG8gZWFjaCBwb2ludCBpbiB0aGUgdmVjdG9yLg0KDQpMZXQncyB0cnkgdXNpbmcgYSBsaXN0IGluc3RlYWQNCmBgYHtyfQ0KQTwtYygxOjkpDQpCPC1jKDE6MTIpDQpDPC1jKDE6MTUpDQpteS5sc3Q8LWxpc3QoQSxCLEMpDQpsYXBwbHkobXkubHN0LCBzdW0pDQpgYGANClRoaXMgdGltZSwgdGhlIGxhcHBseSBmdW5jdGlvbiBzZWVtZWQgdG8gd29yayBiZXR0ZXIuIFRoZSBmdW5jdGlvbiBzdW1tZWQgZWFjaCB2ZWN0b3IgaW4gdGhlIGxpc3QNCmFuZCByZXR1cm5lZCBhIGxpc3Qgb2YgdGhlIDMgc3Vtcy4gDQoNCiMjIyBFeGFtcGxlIDI6IHNhcHBseQ0Kc2FwcGx5IHdvcmtzIGp1c3QgbGlrZSBsYXBwbHksIGJ1dCB3aWxsIHNpbXBsaWZ5IHRoZSBvdXRwdXQgaWYgcG9zc2libGUuIFRoaXMgbWVhbnMgdGhhdCBpbnN0ZWFkDQpvZiByZXR1cm5pbmcgYSBsaXN0IGxpa2UgbGFwcGx5LCBpdCB3aWxsIHJldHVybiBhIHZlY3RvciBpbnN0ZWFkIGlmIHRoZSBkYXRhIGlzIHNpbXBsaWZpYWJsZS4NCg0KYGBge3J9DQpzYXBwbHkodmVjLCBzdW0pDQpgYGANCg0KYGBge3J9DQpzYXBwbHkobXkubHN0LCBzdW0pDQpgYGANClNlZSBob3cgdGhlc2UgdHdvIGV4YW1wbGVzIGdhdmUgdGhlIHNhbWUgYW5zd2VycywgYnV0IHJldHVybmVkIGEgdmVjdG9yIGluc3RlYWQ/DQoNCiMjIyBFeGFtcGxlIDM6IHZhcHBseQ0KdmFwcGx5IGlzIHNpbWlsYXIgdG8gc2FwcGx5LCBidXQgaXQgcmVxdWlyZXMgeW91IHRvIHNwZWNpZnkgd2hhdCB0eXBlIG9mIGRhdGEgeW91IGFyZSBleHBlY3RpbmcNCnRoZSBhcmd1bWVudHMgZm9yIHZhcHBseSBhcmUgdmFwcGx5KFgsIEZVTiwgRlVOLlZBTFVFKS4NCkZVTi5WQUxVRSBpcyB3aGVyZSB5b3Ugc3BlY2lmeSB0aGUgdHlwZSBvZiBkYXRhIHlvdSBhcmUgZXhwZWN0aW5nLg0KSSBhbSBleHBlY3RpbmcgZWFjaCBpdGVtIGluIHRoZSBsaXN0IHRvIHJldHVybiBhIHNpbmdsZSBudW1lcmljIHZhbHVlLCBzbyBGVU4uVkFMVUUgPSBudW1lcmljKDEpLg0KDQpgYGB7cn0NCnZhcHBseSh2ZWMsIHN1bSwgbnVtZXJpYygxKSkNCmBgYA0KDQpgYGB7cn0NCnZhcHBseShteS5sc3QsIHN1bSwgbnVtZXJpYygxKSkNCmBgYA0KDQpJZiB5b3VyIGZ1bmN0aW9uIHdlcmUgdG8gcmV0dXJuIG1vcmUgdGhhbiBvbmUgbnVtZXJpYyB2YWx1ZSwgRlVOLlZBTFVFID0gbnVtZXJpYygxKSB3aWxsIGNhdXNlIHRoZSBmdW5jdGlvbiB0byByZXR1cm4gYW4gZXJyb3IuIFRoaXMgY291bGQgYmUgdXNlZnVsIGlmIHlvdSBhcmUgZXhwZWN0aW5nIG9ubHkgb25lIHJlc3VsdCBwZXIgc3ViamVjdC4gDQpgYGB7cn0NCiN2YXBwbHkobXkubHN0LCBmdW5jdGlvbih4KSB4KzIsIG51bWVyaWMoMSkpDQpgYGANCg0KIyMjIEV4YW1wbGUgNDogVHJhbnNmb3JtaW5nIGRhdGEgd2l0aCBzYXBwbHkNCkxpa2UgYXBwbHksIHRoZXNlIGZ1bmN0aW9ucyBjYW4gYWxzbyBiZSB1c2VkIGZvciB0cmFuc2Zvcm1pbmcgZGF0YSBpbnNpZGUgdGhlIGxpc3QNCmBgYHtyfQ0KbXkubHN0MiA8LSBzYXBwbHkobXkubHN0LCBmdW5jdGlvbih4KSB4KjIpDQpteS5sc3QyDQpgYGANCg0KIyMjIFdoaWNoIGZ1bmN0aW9uIHNob3VsZCBJIHVzZSwgbGFwcGx5LCBzYXBwbHksIG9yIHZhcHBseT8NCg0KSWYgeW91IGFyZSB0cnlpbmcgdG8gZGVjaWRlIHdoaWNoIG9mIHRoZXNlIHRocmVlIGZ1bmN0aW9ucyB0byB1c2UsIGJlY2F1c2UgaXQgaXMgdGhlIHNpbXBsZXN0LCBJIHdvdWxkIHN1Z2dlc3QgdG8gdXNlIHNhcHBseSBpZiBwb3NzaWJsZS4gSWYgeW91IGRvIG5vdCB3YW50IHlvdXIgcmVzdWx0cyB0byBiZSBzaW1wbGlmaWVkIHRvIGEgdmVjdG9yLCBsYXBwbHkgc2hvdWxkIGJlIHVzZWQuIElmIHlvdSB3YW50IHRvIHNwZWNpZnkgdGhlIHR5cGUgb2YgcmVzdWx0IHlvdSBhcmUgZXhwZWN0aW5nLCB1c2UgdmFwcGx5Lg0KDQoNCiMgdGFwcGx5DQoNClNvbWV0aW1lcyB5b3UgbWF5IHdhbnQgdG8gcGVyZm9ybSB0aGUgYXBwbHkgZnVuY3Rpb24gb24gc29tZSBkYXRhLCBidXQgaGF2ZSBpdCBzZXBhcmF0ZWQgYnkgDQpmYWN0b3IuIEluIHRoYXQgY2FzZSwgeW91IHNob3VsZCB1c2UgdGFwcGx5LiBMZXQncyB0YWtlIGEgbG9vayBhdCB0aGUgaW5mb3JtYXRpb24gZm9yIHRhcHBseS4NCg0KYGBge3IsIGV2YWw9RkFMU0V9DQo/dGFwcGx5DQpgYGANClRoZSBhcmd1bWVudHMgZm9yIHRhcHBseSBhcmUgdGFwcGx5KFgsIElOREVYLCBGVU4pLiBUaGUgb25seSBuZXcgYXJndW1lbnQgaXMgSU5ERVgsIHdoaWNoIGlzIHRoZSANCmZhY3RvciB5b3Ugd2FudCB0byB1c2UgdG8gc2VwYXJhdGUgdGhlIGRhdGEuDQoNCiMjIyBFeGFtcGxlIDE6IE1lYW5zIHNwbGl0IGJ5IGNvbmRpdGlvbg0KRmlyc3QsIGxldCdzIGNyZWF0ZSBkYXRhIHdpdGggYW4gZmFjdG9yIGZvciBpbmRleGluZy4gRGF0YXNldCB0IHdpbGwgYmUgY3JlYXRlZCBieSBhZGRpbmcgYSBmYWN0b3IgdG8gbWF0cml4IG0gYW5kIGNvbnZlcnRpbmcgaXQgdG8gYSBkYXRhZnJhbWUuIA0KDQpgYGB7cn0NCnRkYXRhIDwtIGFzLmRhdGEuZnJhbWUoY2JpbmQoYygxLDEsMSwxLDEsMiwyLDIsMiwyKSwgbXkubWF0cngpKQ0KY29sbmFtZXModGRhdGEpDQpgYGANCk5vdyBsZXQncyB1c2UgY29sdW1uIDEgYXMgdGhlIGluZGV4IGFuZCBmaW5kIHRoZSBtZWFuIG9mIGNvbHVtbiAyDQoNCmBgYHtyfQ0KdGFwcGx5KHRkYXRhJFYyLCB0ZGF0YSRWMSwgbWVhbikNCmBgYA0KDQojIyMgRXhhbXBsZSAyOiBDb21iaW5pbmcgZnVuY3Rpb25zDQpZb3UgY2FuIHVzZSB0YXBwbHkgdG8gZG8gc29tZSBxdWljayBzdW1tYXJ5IHN0YXRpc3RpY3Mgb24gYSB2YXJpYWJsZSBzcGxpdCBieSBjb25kaXRpb24uIEluIHRoaXMgDQpleGFtcGxlLCBJIGNyZWF0ZWQgYSBmdW5jdGlvbiB0aGF0IHJldHVybnMgYSB2ZWN0b3Igb2Zib3RoIHRoZSBtZWFuIGFuZCBzdGFuZGFyZCBkZXZpYXRpb24uIFlvdSANCmNhbiBjcmVhdGUgYSBmdW5jdGlvbiBsaWtlIHRoaXMgZm9yIGFueSBhcHBseSBmdW5jdGlvbiwgbm90IGp1c3QgdGFwcGx5Lg0KYGBge3J9DQpzdW1tYXJ5IDwtIHRhcHBseSh0ZGF0YSRWMiwgdGRhdGEkVjEsIGZ1bmN0aW9uKHgpIGMobWVhbih4KSwgc2QoeCkpKQ0Kc3VtbWFyeQ0KYGBgDQoNCiMgbWFwcGx5DQp0aGUgbGFzdCBhcHBseSBmdW5jdGlvbiBJIHdpbGwgY292ZXIgaXMgbWFwcGx5Lg0KYGBge3IsIGV2YWw9RkFMU0V9DQo/bWFwcGx5DQpgYGANCnRoZSBhcmd1bWVudHMgZm9yIG1hcHBseSBhcmUgbWFwcGx5KEZVTiwgLi4uLCBNb3JlQXJncyA9IE5VTEwsIFNJTVBMSUZZID0gVFJVRSwgVVNFLk5BTUVTID0gVFJVRSkuDQpGaXJzdCB5b3UgbGlzdCB0aGUgZnVuY3Rpb24sIGZvbGxvd2VkIGJ5IHRoZSB2ZWN0b3JzIHlvdSBhcmUgdXNpbmcNCnRoZSByZXN0IG9mIHRoZSBhcmd1bWVudHMgaGF2ZSBkZWZhdWx0IHZhbHVlcyBzbyB0aGV5IGRvbid0IG5lZWQgdG8gYmUgY2hhbmdlZCBmb3Igbm93LiANCldoZW4geW91IGhhdmUgYSBmdW5jdGlvbiB0aGF0IHRha2VzIDIgYXJndW1lbnRzLCB0aGUgZmlyc3QgdmVjdG9yIGdvZXMgaW50byB0aGUgZmlyc3QgYXJndW1lbnQNCmFuZCB0aGUgc2Vjb25kIHZlY3RvciBnb2VzIGludG8gdGhlIHNlY29uZCBhcmd1bWVudC4NCg0KIyMjIEV4YW1wbGUgMTogVW5kZXJzdGFuZGluZyBtYXBwbHkNCkluIHRoaXMgZXhhbXBsZSwgMTo5IGlzIHNwZWNpZnlpbmcgdGhlIHZhbHVlIHRvIHJlcGVhdCwgYW5kIDk6MSBpcyBzcGVjaWZ5aW5nIGhvdyBtYW55IHRpbWVzDQp0byByZXBlYXQuIFRoaXMgb3JkZXIgaXMgYmFzZWQgb24gdGhlIG9yZGVyIG9mIGFyZ3VtZW50cyBpbiB0aGUgcmVwIGZ1bmN0aW9uIGl0c2VsZi4NCmBgYHtyfQ0KbWFwcGx5KHJlcCwgMTo5LCA5OjEpDQpgYGANCg0KIyMjIEV4YW1wbGUgMjogQ3JlYXRpbmcgYSBuZXcgdmFyaWFibGUNCkFub3RoZXIgdXNlIGZvciBtYXBwbHkgd291bGQgYmUgdG8gY3JlYXRlIGEgbmV3IHZhcmlhYmxlLiBGb3IgZXhhbXBsZSwgdXNpbmcgZGF0YXNldCB0LCBJIGNvdWxkDQpkaXZpZGUgb25lIGNvbHVtbiBieSBhbm90aGVyIGNvbHVtbiB0byBjcmVhdGUgYSBuZXcgdmFsdWUuIFRoaXMgd291bGQgYmUgdXNlZnVsIGZvciBjcmVhdGluZyBhIA0KcmF0aW8gb2YgdHdvIHZhcmlhYmxlcyBhcyBzaG93biBpbiB0aGUgZXhhbXBsZSBiZWxvdy4gDQoNCmBgYHtyfQ0KdGRhdGEkVjUgPC0gbWFwcGx5KGZ1bmN0aW9uKHgsIHkpIHgveSwgdGRhdGEkVjIsIHRkYXRhJFY0KQ0KdGRhdGEkVjUNCmBgYA0KDQojIyMgRXhhbXBsZSAzOiBTYXZpbmcgZGF0YSBpbnRvIGEgcHJlbWFkZSB2ZWN0b3INCldoZW4gdXNpbmcgYW4gYXBwbHkgZmFtaWx5IGZ1bmN0aW9uIHRvIGNyZWF0ZSBhIG5ldyB2YXJpYWJsZSwgb25lIG9wdGlvbiBpcyB0byBjcmVhdGUgYSBuZXcgdmVjdG9yIGFoZWFkIG9mIHRpbWUgd2l0aCB0aGUgc2l6ZSBvZiB0aGUgdmVjdG9yIHByZS1hbGxvY2F0ZWQuIEkgY3JlYXRlZCBhIG51bWVyaWMgdmVjdG9yIG9mIGxlbmd0aCAxMCB1c2luZyB0aGUgdmVjdG9yIGZ1bmN0aW9uLiBUaGUgYXJndW1lbnRzIGZvciB0aGUgdmVjdG9yIGZ1bmN0aW9uIGFyZSB2ZWN0b3IobW9kZSwgbGVuZ3RoKS4gSW5zaWRlIG1hcHBseSBJIGNyZWF0ZWQgYSBmdW5jdGlvbiB0byBtdWx0aXBsZSB0d28gdmFyaWFibGVzIHRvZ2V0aGVyLiBUaGUgcmVzdWx0cyBvZiB0aGUgbWFwcGx5IGZ1bmN0aW9uIGFyZSB0aGVuIHNhdmVkIGludG8gdGhlIHZlY3Rvci4NCg0KYGBge3J9DQpuZXcudmVjIDwtIHZlY3Rvcihtb2RlID0gIm51bWVyaWMiLCBsZW5ndGggPSAxMCkNCm5ldy52ZWMgPC0gbWFwcGx5KGZ1bmN0aW9uKHgsIHkpIHgqeSwgdGRhdGEkVjMsIHRkYXRhJFY0KQ0KbmV3LnZlYw0KYGBgDQoNCiMgVXNpbmcgYXBwbHkgZnVuY3Rpb25zIG9uIHJlYWwgZGF0YXNldHMNClRoaXMgbGFzdCBzZWN0aW9uIHdpbGwgYmUgYSBmZXcgZXhhbXBsZXMgb2YgdXNpbmcgYXBwbHkgZnVuY3Rpb25zIG9uIHJlYWwgZGF0YS5UaGlzIHNlY3Rpb24gd2lsbA0KbWFrZSB1c2Ugb2YgdGhlIE1BU1MgcGFja2FnZSwgd2hpY2ggaXMgYSBjb2xsZWN0aW9uIG9mIHB1YmxpY2x5IGF2YWlsYWJsZSBkYXRhc2V0cy4gUGxlYXNlDQppbnN0YWxsIE1BU1MgaWYgeW91IGRvIG5vdCBhbHJlYWR5IGhhdmUgaXQuIElmIHlvdSBkbyBub3QgaGF2ZSBNQVNTIGluc3RhbGxlZCwgeW91IGNhbiB1bmNvbW1lbnQNCnRoZSBjb2RlIGJlbG93Lg0KDQpgYGB7cn0NCiNpbnN0YWxsLnBhY2thZ2VzKCJNQVNTIikNCmxpYnJhcnkoTUFTUykNCmBgYA0KDQpsb2FkIHRoZSBzdGF0ZSBkYXRhc2V0LiBJdCBjb250YWlucyBpbmZvcm1hdGlvbiBhYm91dCBhbGwgNTAgc3RhdGVzDQpgYGB7cn0NCmRhdGEoc3RhdGUpDQpgYGANCkxldCdzIGxvb2sgYXQgdGhlIGRhdGEgd2Ugd2lsbCBiZSB1c2luZy4gV2Ugd2lsbCBiZSB1c2luZyB0aGUgc3RhdGUueDc3IGRhdGFzZXQNCmBgYHtyfQ0KaGVhZChzdGF0ZS54NzcpDQpzdHIoc3RhdGUueDc3KQ0KYGBgDQpBbGwgdGhlIGRhdGEgaW4gdGhlIGRhdGFzZXQgaGFwcGVucyB0byBiZSBudW1lcmljLCB3aGljaCBpcyBuZWNlc3Nhcnkgd2hlbiB0aGUgZnVuY3Rpb24gaW5zaWRlIHRoZSBhcHBseSBmdW5jdGlvbiByZXF1aXJlcyBudW1lcmljIGRhdGEuDQoNCiMjIyBFeGFtcGxlIDE6IHVzaW5nIGFwcGx5IHRvIGdldCBzdW1tYXJ5IGRhdGENCllvdSBjYW4gdXNlIGFwcGx5IHRvIGZpbmQgbWVhc3VyZXMgb2YgY2VudHJhbCB0ZW5kZW5jeSBhbmQgZGlzcGVyc2lvbg0KYGBge3J9DQphcHBseShzdGF0ZS54NzcsIDIsIG1lYW4pDQphcHBseShzdGF0ZS54NzcsIDIsIG1lZGlhbikNCmFwcGx5KHN0YXRlLng3NywgMiwgc2QpDQpgYGANCg0KIyMjIEV4YW1wbGUgMjogU2F2aW5nIHRoZSByZXN1bHRzIG9mIGFwcGx5DQoNCkluIHRoaXMsIEkgY3JlYXRlZCBvbmUgZnVuY3Rpb24gdGhhdCBnaXZlcyB0aGUgbWVhbiBhbmQgU0QsIGFuZCBhbm90aGVyIHRoYXQgZ2l2ZSBtaW4sIG1lZGlhbiwgYW5kIG1heC4gVGhlbiBJIHNhdmVkIHRoZW0gYXMgb2JqZWN0cyB0aGF0IGNvdWxkIGJlIHVzZWQgbGF0ZXIuDQpgYGB7cn0NCnN0YXRlLnN1bW1hcnk8LSBhcHBseShzdGF0ZS54NzcsIDIsIGZ1bmN0aW9uKHgpIGMobWVhbih4KSwgc2QoeCkpKSANCnN0YXRlLnN1bW1hcnkNCnN0YXRlLnJhbmdlIDwtIGFwcGx5KHN0YXRlLng3NywgMiwgZnVuY3Rpb24oeCkgYyhtaW4oeCksIG1lZGlhbih4KSwgbWF4KHgpKSkNCnN0YXRlLnJhbmdlDQpgYGANCg0KIyMjIEV4YW1wbGUgMzogVXNpbmcgbWFwcGx5IHRvIGNvbXB1dGUgYSBuZXcgdmFyaWFibGUNCkluIHRoaXMgZXhhbXBsZSwgSSB3YW50IHRvIGZpbmQgdGhlIHBvcHVsYXRpb24gZGVuc2l0eSBmb3IgZWFjaCBzdGF0ZS4gSW4gb3JkZXIgdG8gZG8gdGhpcywgSSANCndhbnQgdG8gZGl2aWRlIHBvcHVsYXRpb24gYnkgYXJlYS4gc3RhdGUuYXJlYSBhbmQgc3RhdGUueDc3IGFyZSBub3QgZnJvbSB0aGUgc2FtZSBkYXRhc2V0LCBidXQgDQp0aGF0IGlzIGZpbmUgYXMgbG9uZyBhcyB0aGUgdmVjdG9ycyBhcmUgdGhlIHNhbWUgbGVuZ3RoIGFuZCB0aGUgZGF0YSBpcyBpbiB0aGUgc2FtZSBvcmRlci4gQm90aA0KdmVjdG9ycyBhcmUgYWxwaGFiZXRpY2FsbHkgYnkgc3RhdGUsIHNvIG1hcHBseSBjYW4gYmUgdXNlZC4NCmBgYHtyfQ0KcG9wdWxhdGlvbiA8LSBzdGF0ZS54NzdbMTo1MF0NCmFyZWEgPC0gc3RhdGUuYXJlYQ0KcG9wLmRlbnMgPC0gbWFwcGx5KGZ1bmN0aW9uKHgsIHkpIHgveSwgcG9wdWxhdGlvbiwgYXJlYSkNCnBvcC5kZW5zDQpgYGANCg0KIyMjIEV4YW1wbGUgNDogVXNpbmcgdGFwcGx5ICB0byBleHBsb3JlIHBvcHVsYXRpb24gYnkgcmVnaW9uDQpJbiB0aGlzIGV4YW1wbGUsIEkgd2FudCB0byBmaW5kIG91dCBzb21lIGluZm9ybWF0aW9uIGFib3V0IHRoZSBwb3B1bGF0aW9uIG9mIHN0YXRlcyBzcGxpdCBieQ0KcmVnaW9uLiBzdGF0ZS5yZWdpb24gaXMgYSBmYWN0b3Igd2l0aCBmb3VyIGxldmVsczogTm9ydGhlYXN0LCBTb3V0aCwgTm9ydGggQ2VudHJhbCwgYW5kIFdlc3QuDQpGb3IgZWFjaCByZWdpb24sIEkgd2FudCB0aGUgbWluaW11bSwgbWVkaWFuLCBhbmQgbWF4aW11bSBwb3B1bGF0aW9ucy4NCg0KYGBge3J9DQpyZWdpb24uaW5mbyA8LSB0YXBwbHkocG9wdWxhdGlvbiwgc3RhdGUucmVnaW9uLCBmdW5jdGlvbih4KSBjKG1pbih4KSwgbWVkaWf*ckHgpLCBtYXgoeCkpKQ0KcmVnaW9uLmluZm8NCmBgYA0KDQojIFJlZmVyZW5jZXMNCkhlcmUgYXJlIHNvbWUgc291cmNlcyBJIHVzZWQgdG8gaGVscCBtZSBjcmVhdGUgdGhpcyBjaGFwdGVyOg0KDQpEYXRhY2FtcCB0dXRvcmlhbCBvbiBhcHBseSBmdW5jdGlvbnM6IGh0dHBzOi8vd3d3LmRhdGFjYW1wLmNvbS9jb21tdW5pdHkvdHV0b3JpYWxzL3ItdHV0b3JpYWwtYXBwbHktZmFtaWx5DQoNCnItYmxvZ2dlcnM6IFVzaW5nIGFwcGx5LCBzYXBwbHksIGFuZCBsYXBwbHkgaW4gUjogaHR0cHM6Ly93d3cuci1ibG9nZ2Vycy5jb20vdXNpbmctYXBwbHktc2FwcGx5LWxhcHBseS1pbi1yLw0KDQpzdGFja292ZXJmbG93OiBXaHkgaXMgdmFwcGx5IHNhZmVyIHRoYW4gc2FwcGx5PzogaHR0cDovL3N0YWNrb3ZlcmZsb3cuY29tL3F1ZXN0aW9ucy8xMjMzOTY1MC93aHktaXMtdmFwcGx5LXNhZmVyLXRoYW4tc2FwcGx5DQoNCg0KPHNjcmlwdD4NCiAgKGZ1bmN0aW9uKGkscyxvLGcscixhLG0pe2lbJ0dvb2dsZUFuYWx5dGljc09iamVjdCddPXI7aVtyXT1pW3JdfHxmdW5jdGlvbigpew0KICAoaVtyXS5xPWlbcl0ucXx8W10pLnB1c2goYXJndW1lbnRzKX0saVtyXS5sPTEqbmV3IERhdGUoKTthPXMuY3JlYXRlRWxlbWVudChvKSwNCiAgbT1zLmdldEVsZW1lbnRzQnlUYWdOYW1lKG8pWzBdO2EuYXN5bmM9MTthLnNyYz1nO20ucGFyZW50Tm9kZS5pbnNlcnRCZWZvcmUoYSxtKQ0KICB9KSh3aW5kb3csZG9jdW1lbnQsJ3NjcmlwdCcsJ2h0dHBzOi8vd3d3Lmdvb2dsZS1hbmFseXRpY3MuY29tL2FuYWx5dGljcy5qcycsJ2dhJyk7DQoNCiAgZ2EoJ2NyZWF0ZScsICdVQS05ODg3ODc5My0xJywgJ2F1dG8nKTsNCiAgZ2EoJ3NlbmQnLCAncGFnZXZpZXcnKTsNCg0KPC9zY3JpcHQ+DQo=

FAQs

How to use apply() function in R? ›

the apply function looks like this: apply(X, MARGIN, FUN).

X is an array or matrix (this is the data that you will be performing the function on)
Margin specifies whether you want to apply the function across rows (1) or columns (2)
FUN is the function you want to use.

Tell Me More ›

What is the apply family of functions? ›

The apply() function is the basic model of the family of apply functions in R, which includes specific functions like lapply() , sapply() , tapply() , mapply() , vapply() , rapply() , bapply() , eapply() , and others.

What does applying Lapply function on a matrix returns ________? ›

lapply returns a list of the same length as X , each element of which is the result of applying FUN to the corresponding element of X . sapply is a user-friendly version and wrapper of lapply by default returning a vector, matrix or, if simplify = "array" , an array if appropriate, by applying simplify2array() .

Explore More ›

What is the apply () function? ›

The apply() method is one of the most common methods of data preprocessing. It simplifies applying a function on each element in a pandas Series and each row or column in a pandas DataFrame.

Read On ›

How do I apply a function to an element of a list in R? ›

lapply() function in R Programming Language is used to apply a function over a list of elements. lapply() function is used with a list and performs the following operations: lapply(List, length): Returns the length of objects present in the list, List.

What is the family of functions example? ›

A family of functions is a function that changes depending on the particular values of certain parame- ters. An example of such a family of functions would be something like f(x) = a(x-b)2 +c. Depending on the values of a, b, and c, this function could take multiple forms.

Learn More Now ›

What are the four functions of the family? ›

Murdock found that the nuclear family was a universal family structure because it performed four major, crucial functions for wider society. These are the educational, economic, reproductive, and sexual functions.

How to find family function? ›

If two functions have the same degree, they are said to be in the same function family because they are the same type of function, even if the numbers are different. It is also important to note that these are determined when in function notation, f(x) or y=, and that the only variables used are f(x)/y and x.

What is the apply function over matrix in R? ›

Applying Functions

apply_matrix() : The functions must take a matrix as input. In base R, this is similar to simply calling fun(matrix_object) .
apply_row() : The functions must take a vector as input. The vector will be a matrix row. ...
apply_column() : The functions must take a vector as input.

Show Me More ›

What is the difference between apply and Lapply in R? ›

lapply , you see that the syntax looks like the apply() function. The difference is that: It can be used for other objects like dataframes, lists or vectors; and. The output returned is a list (which explains the “l” in the function name), which has the same number of elements as the object passed to it.

Learn More Now ›

How to apply the same function to all rows and columns of a matrix? ›

Using the apply() Function

m is the matrix.
dimcode is the dimension, equal to 1 if the function applies to rows or 2 for columns.
f is the function to be applied.
fargs is an optional set of arguments to be supplied to f .

Discover More Details ›

How to apply a function to each column in a dataframe in R? ›

Applying a Function to Multiple Columns

But what if we want to apply the same function to multiple columns in a data frame? For this, we can use the mutate_all function from the dplyr package. The mutate_all function takes a data frame as input and applies a function to all columns.

Show Me More ›

How to use which function for a vector in R? ›

Syntax of which() function in R

X = An input logical vector.
Arr. ind = Returns the array indices if x is an array.
useNames = Indicates the dimension names of an array.

Aug 3, 2022

View Details ›

How to use conditional formatting in R? ›

Method

Select your table.
Copy the table name from General > GENERAL > Name.
Select the Calculation icon. ...
Go to General > R CODE in the object inspector.
Paste the below CustomTable function into your output to adjust fonts, font colors, lines, shading, and the border: library(RColorBrewer)

More items...

May 31, 2024

How to use split() in R? ›

Split() is a built-in R function that divides a vector or data frame into groups according to the function's parameters. It takes a vector or data frame as an argument and divides the information into groups. The syntax for this function is as follows: split(x, f, drop = FALSE, ...)