A couple of variants of the functions `mutate()`

and `transmute()`

which are described here allow for modifying the content of a selection of variable(s). This means that, instead of adding new columns with the results of a given transformation/operation, the contents of the original variables are replaced by these results.

These variants are:

`mutate_if()`

: modify variables based on a condition.`mutate_at()`

: modify a selection of variables.`transmute_if()`

: modify variables based on a condition and then drop the unmodified variables.`transmute_at()`

: modify columns by applying functions to a selection of variables and then drop the unmodified variables.

#### Modify variables based on a condition with mutate_if()

`mutate_if()`

modifies variables only if a given condition is fulfilled. The condition may be a logical operation which result is TRUE/FALSE. Such operations are for example `is.numeric`

(which checks whether the variable is a number vs. a factor or text), `is.integer`

(which checks whether the variable is an integer vs. decimal), `is.factor`

,etc. Here, we take the following example where we multiply by 10 all the variables which are defined as *numeric*. Arithmetic operations, unlike other functions, must by written in `list(~)`

, and in our case, it will be written `list(~.*10)`

:

Orange %>% mutate_if(is.numeric, list(~.*10))

Note that the values in `Tree`

have not been multiplied by 10 since the variable is defined in the data frame as an ordered factor, not a number, as confirmed by the command `str(Orange)`

which gives details about the nature of the variables:

As you can see here above thanks to `str`

, `Tree`

is defined as *ordered factor*.

We can also use `mutate_if()`

to transform the nature of `Tree`

from *ordered factor* to *numeric*:

Orange %>% mutate_if(is.factor, as.numeric) %>% str

#### Modify a selection of variables with mutate_at()

`mutate_at()`

may be used to transform the content of a predefined selection of variables. In this function, the variables to be modified must be listed with `vars()`

. Then, like in `mutate_if()`

, arithmetic operations shall be applied with `list(~)`

, while functions may be simply added *as is*. Here we selectively transform `age`

by multiplying it by 10:

Orange %>% mutate_at(vars(age), list(~.*10))

We may also use the function to transform `age`

into a factor variable with `as.factor`

. In this example, we use `str`

again to reveal the nature of the variables:

Orange %>% mutate_at(vars(age), as.factor) %>% str

#### Modify variables based on a condition and then drop the unmodified variables with transmute_if()

In a similar way to `mutate()`

, `transmute()`

modifies the content of variables, but it actually drops the variables which are not modified in the output table (as we have seen here). This applies also to `transmute_if()`

. `transmute_if()`

modifies conditionally the content of variables like `mutate_if()`

, but drops the rest. Here, we take the following example where we multiply by 10 all the variables which are defined as *numeric*:

Orange %>% transmute_if(is.numeric, list(~.*10))

As expected, `age`

and `circumference`

have been transformed and kept, while the variable `Tree`

was

discarded.

#### Modify a selection of variables and then drop the unmodified variables with transmute_at()

Like `mutate_at()`

, `transmute_at()`

modifies the content of a selection of variables, but in this case the function discards unmodified variables in the output table. Here is an example where `age`

is multiplied by 10, and is the only variable that shows up in the output:

Orange %>% transmute_at(vars(age), list(~*10))