#### Overview of this book

This cookbook offers a range of data analysis samples in simple and straightforward R code, providing step-by-step resources and time-saving methods to help you solve data problems efficiently. The first section deals with how to create R functions to avoid the unnecessary duplication of code. You will learn how to prepare, process, and perform sophisticated ETL for heterogeneous data sources with R packages. An example of data manipulation is provided, illustrating how to use the “dplyr” and “data.table” packages to efficiently process larger data structures. We also focus on “ggplot2” and show you how to create advanced figures for data exploration. In addition, you will learn how to build an interactive report using the “ggvis” package. Later chapters offer insight into time series analysis on financial data, while there is detailed information on the hot topic of machine learning, including data classification, regression, clustering, association rule mining, and dimension reduction. By the end of this book, you will understand how to resolve issues and will be able to comfortably offer solutions to problems encountered while performing data analysis.
R for Data Science Cookbook
Credits
www.PacktPub.com
Preface
Free Chapter
Functions in R
Data Preprocessing and Preparation
Visualizing Data with ggplot2
Making Interactive Reports
Simulation from Probability Distributions
Statistical Inference in R
Time Series Mining with R
Index

## Performing lazy evaluation

R functions evaluate arguments lazily; the arguments are evaluated as they are needed. Thus, lazy evaluation reduces the time needed for computation. In the following recipe, we will demonstrate how lazy evaluation works.

Ensure that you completed the previous recipes by installing R on your operating system.

### How to do it...

Perform the following steps to see how lazy evaluation works:

1. First, we create a `lazyfunc` function with `x` and `y` as the argument, but only return `x`:

```>lazyfunc<- function(x, y){
+ x
+ }
>lazyfunc(3)
[1] 3
```
2. On the other hand, if the function returns the summation of `x` and `y` but we do not pass `y` into the function, an error occurs:

```>lazyfunc2<- function(x, y){
+ x + y
+ }
>lazyfunc2(3)
Error in lazyfunc2(3) : argument "y" is missing, with no default
```
3. We can also specify a default value to the `y` argument in the function but pass the `x` argument only to the function:

```>lazyfunc4<- function(x, y=2){
+ x + y
+ }
>lazyfunc4(3)
[1] 5
```
4. In addition to this, we can use lazy evaluation to perform Fibonacci computation in a function:

```>fibonacci<- function(n){
+ if (n==0)
+ return(0)
+ if (n==1)
+ return(1)
+ return(fibonacci(n-1) + fibonacci(n-2))
+ }
>fibonacci(10)
[1] 55
```

### How it works...

R performs a lazy evaluation to evaluate an expression if its value is needed. This type of evaluation strategy has the following three advantages:

• It increases performance due to the avoidance of repeated evaluation

• It recursively constructs an infinite data structure

• It inherently includes iteration in its data structure

In this recipe, we demonstrate some lazy evaluation examples in the R code. In our first example, we create a function with two arguments, `x` and `y`, but return only `x`. Due to the characteristics of lazy evaluation, we can successfully obtain function returns even though we pass the value of `x` to the function. However, if the function return includes both `x` and `y`, as step 2 shows, we will get an error message because we only passed one value to the function. If we set a default value to `y`, then we do not necessarily need to pass both `x` and `y` to the function.

As lazy evaluation has the advantage of creating an infinite data structure without an infinite loop, we use a Fibonacci number generator as the example. Here, this function first creates an infinite list of Fibonacci numbers and then extracts the nth element from the list.

### There's more...

Additionally, we can use the `force` function to check whether `y` exists:

```>lazyfunc3<- function(x, y){
+ force(y)
+ x
+ }
>lazyfunc3(3)
Error in force(y) : argument "y" is missing, with no default
>input_function<- function(x, func){
+ func(x)
+ }
>input_function(1:10, sum)
[1] 55
```