The post Components of Functions in R Language appeared first on R Language Frequently Asked Questions.

]]>Functions in the R Language are objects with three basic components. The components of functions in R language are:

- A formal argument list
- A body
- An environment

Let us discuss the components of functions in R language in detail.

To learn about Formal arguments in R language, see the post formal argument, also see the basics about functions in R Language.

The body of a function is parsed R statements. The body of a function is usually a collection of statements in braces but it can be a single statement, a symbol, or even a constant.

The environment of a function is the environment that was active at the time that the function was created. The environment of a function is a structural component of the function and belongs to the function itself.

A fourth component of a function in R language can be considered as a “Return Value” by a function.

The last object called within a function is returned by the function and therefore available for assignment. Functions can return only a single value but in practice, this is not a limitation as a list containing any number of objects can be returned. Objects can be returned visible or invisible. This option does not affect the assignment side but affects the way results are displayed when the function is called.

y <- function(n){ out <- runif(n) cat (head(out)) invisible(out) }

A function closure or closure is a function together with a referencing environment. Almost all functions in R are closures as they remember the environment where they were created. The functions that cannot be classified as closures, and therefore do not have a referencing environment, are known as primitives.

In R, internal functions are called the underlying `C`

code. These `sum()`

and `c()`

are good cases in point:

environment(sum)

When we call a function, a new environment is created to hold the function’s execution, and normally, that environment is destroyed when the function exists. But, if we define a function `g()`

that returns a `f()`

, the environment where `f()`

is created is the execution environment of g(), that is, the execution environment of g() is the referencing environment of f(). As a consequence, the execution environment of g() is not destroyed as g() exists but it persists as long as f() exists. Finally as f() remembers all objects bound to its referencing environment f() remembers all objects bound to the execution environment of `g()`

.

We can use the referencing environment of `f()`

, to hold any of the objects and these will be available to `f()`

.

g <- function(){ y <- 1 function(x){ x + y } f1 <- g() print(f1) f1(3)

Closures can be used to write functions that in turn closures can be used to generate new functions. This allows us to have a double layer of development: a first layer that is used to do all the complex work in common to all functions and a second layer that defines the details of each function.

f <- function(i){ function(x){ x+i } } f1 <- f(1) f2 <- f(2) f2(4)

By understanding these components, one can effectively create and use functions to enhance one’s R programming.

Note that in R language:

- Functions can be nested within other functions.
- Functions can access variables from the environment where they are defined (lexical scoping).
- R provides many built-in functions for various tasks.
- One can create customized functions to automate repetitive tasks and improve code readability.

The post Components of Functions in R Language appeared first on R Language Frequently Asked Questions.

]]>The post Formal Arguments in R appeared first on R Language Frequently Asked Questions.

]]>Formal arguments in R are essentially variables you define within a function’s code block. These arguments act as placeholders for the data that are provided when a user uses the function. Formal are the formal arguments of function returned as an object of class `pairlist`

which can be thought of as something similar to a list with an important difference:

is.null(pairlist()) is.null(list())

That is a pairlist of length zero is NULL while a list is not.

Formal arguments in R can be specified by position or by name and we can mix positional matching with matching by name. The following are equivalent.

mean(x = 1:5, trim = 0.1) mean(1:5, trim = 0.1) mean(x = 1:5, 0.1) mean(1:5, 0.1) mean(trim = 0.1, x = 1:5)

Functions formals may also have the construct `symbol=default`

, which unless differently specified, forces any argument to be used with its default value. Specifically, functions `mean()`

also have a third argument `na.rm`

that defaults to `FALSE`

and as a result, passing vectors with `NA`

values to `mean()`

returns `NA`

.

mean(c(1, 2, NA))

while by specifying na.rm=TRUE we get the mean of all non-missing elements of vector x.

mean(c(1, 2, NA), na.rm = TRUE)

we can redefine `mean()`

function that defaults `na.rm`

to `TRUE`

by simply

mean(c(1, 2, NA))

Now we have a copy of `mean.default()`

in our `globalenv`

:

exists("mean.default", envir = globaenv())

also, notice

environment(mean.default)

The `…`

argument of a function is special and can contain any number of `symbol=value`

arguments. The `…`

argument is transformed by R into a list that is simply added to the formal list:

h<-function(x, …){ 0 } formals(h)

The `…`

argument can be used if the number of arguments is unknown. Suppose one wants to define a function that counts the number of rows of any given number of data frames. One can write:

count_rows<-function(…){ list<-list(…) lapply(list, nrow) } count_rows(airquality, cars)

By effectively using formal arguments in R Language, one can create reusable and adaptable functions that make the R code more concise and efficient.

The post Formal Arguments in R appeared first on R Language Frequently Asked Questions.

]]>The post Arithmetic Operators in R appeared first on R Language Frequently Asked Questions.

]]>The article is about making use of arithmetic operators in R Language. The usual arithmetic operations with the usual hierarchy are:

Operator | Short Description |
---|---|

+ | Addition operator |

– | Subtraction operator |

* | Multiplication operator |

/ | Division operator |

^ | Exponent operator |

# Addition of two or more numbers and varaibles 2 + 7 ## output [1] 9 2.2 + 8.13 + 9 ## output [1] 19.33

Note that, the symbol `[1]`

in the output indicates the element number in this output line.

Suppose, one wants to define a variable, e.g., $`x=5$`

R will create an object to store that value and show it when we enter that variable. The object is not displayed on the screen but stored in the active memory of R. The object will be displayed by typing the object name on the R prompt.

To define a variable, we use an assignment operator, i.e., <- (assignment operator) which plays the role of equality (=). For example,

x <- 5 x

The assignment operator (`->`

) may also be used. However, the assignment operator (`->`

) assignment the value from left to right. For example,

x <- 2

will assign the value 2 to variable $x$ and

x ^ 2 -> y

assigns $x^2$ to object (variable) $y$.

Note that by assigning a new value to the same variable, the old value will automatically be over-written (deleted). For example,

x <- 4 x x <-5 x <- 2 x

Usually, spaces are not required to separate the elements of an arithmetic expression.

Note:

- If a command is not complete at the end of a line you will see a “+” sign, meaning you must complete the command.
- Commands are separated by a semi-colon at a new line
- Comments will be lines starting with a hash mark “#”
- The interpreter ignores text to the right of #.

**Question:** Find the distance between 2 points (2, 4, 6), and (4.2, 7.1, 8.6).

**Solution:** The distance between two points say $(x_1,x_2,x_3)$ and $(y_1,y_2,y_3)$ is defined as $$\sqrt{(x_1-y_1)^2 + (x_2-y_2)^2 + (x_3-y_3)^2}$$. The R code may be like:

sqrt((2-4.2)^2 + (4-7.2)^2 + (6-8.6)^2) # alternatively one can store point values such as x1 = 2 x2 = 4 x3 = 6 y1 = 4.2 y2 = 7.1 y3 = 8.6 sqrt((x1-y1)^2 + (x2-y2)^2 + (x3-y3)^2)

The post Arithmetic Operators in R appeared first on R Language Frequently Asked Questions.

]]>