Understanding Function Closures in R and How ecdf Saves its Object

R, a popular programming language for statistical computing and graphics, has a unique way of handling function closures. A closure is a function that remembers its environment when it’s created. In other words, when we create a new function inside another function (also known as an enclosing function), the inner function “remembers” the variables from the outer function.

In this article, we’ll explore what function closures are in R, how ecdf uses them to save its object, and what impact it has on memory usage. We’ll also discuss how to measure the size of an object saved by a closure.

Function Closures in R

A function closure is created when a new function is defined inside another function (the enclosing function). The inner function has access to all variables from the outer function, including non-existent variables if they’re not yet defined. When we execute the inner function, it can “remember” its environment and use those variables.

Here’s an example:

# Define a new function within an existing one
my_new_func <- function() {
  # Access variables from the enclosing function
  outer_func_var = "hello"
  
  # Return the result of the inner function
  return(outer_func_var + "_new")
}

# Call the new function
result = my_new_func()
print(result)  # Outputs: hello_new

In this example, my_new_func has access to all variables from outer_func, including outer_func_var. This means that my_new_func can “remember” its environment and use those variables even after the outer function has returned.

How ecdf Saves its Object

Now that we know about function closures, let’s dive into how ecdf works. The ecdf function in R returns an object that represents the empirical cumulative distribution function of a set of values. This object is created by defining a new function within the ecdf function.

When we create the ecdf object, it saves its environment, which includes the values and their corresponding probabilities. The ecdf function doesn’t directly save these values; instead, it uses a closure to store them in an enclosing environment.

Here’s what happens when we call ecdf(x):

# Create a set of random values
x <- rnorm(1e4)

# Call the ecdf function with x as input
y <- ecdf(x)

In this example, ecdf(x) creates a new object y that represents the empirical cumulative distribution function of x. The ecdf function saves its environment when creating the y object.

Measuring the Size of an Object Saved by a Closure

To measure the size of an object saved by a closure, we can use the pryr::compare_size function. This function compares two objects and reports their relative sizes.

Here’s how to use it:

# Compare the size of y with the sum of its enclosing environment
sapply(codetools::findGlobals(y), function(x) object.size(get(x, environment(y))))

This code finds all global variables in the y object and reports their sizes using the object.size function.

Impact on Memory Usage

The ecdf function saves its enclosing environment when creating the y object. This means that if we create many objects using ecdf, they’ll each occupy some memory.

To understand the impact of this on memory usage, let’s run a simple experiment:

# Create a set of random values
x <- rnorm(1e4)

# Call the ecdf function with x as input 100 times
for (i in 1:100) {
  y <- ecdf(x)
}

# Measure the total memory used by all objects
total_memory_used <- sum(sapply(codetools::findGlobals(y), function(x) object.size(get(x, environment(y)))))
print(total_memory_used)

This code creates a set of random values and calls ecdf with that value 100 times. After each call, it measures the total memory used by all objects saved by closures.

How to Measure Memory Used by Closures

To measure memory used by closures in R, we can use the object.size function combined with codetools::findGlobals. Here’s how:

# Create a set of random values
x <- rnorm(1e4)

# Call the ecdf function with x as input
y <- ecdf(x)

# Measure the size of y and its enclosing environment
sapply(codetools::findGlobals(y), function(x) object.size(get(x, environment(y))))

This code measures the size of y itself and its enclosing environment.

Conclusion

In this article, we explored how function closures in R work and how ecdf uses them to save objects. We also discussed how to measure the size of an object saved by a closure using pryr::compare_size. Additionally, we examined the impact of closures on memory usage.

By understanding how closures work in R, you can better optimize your code for performance and memory efficiency.

Last modified on 2024-06-23