R nested for loop to write multiple functions and plot them

Question

Here is my data:

color   a   b
red     3   1.3
blue    9   1.8
purple  13  1.2
green   4   1.1
orange  7   0.9
yellow  6   2.1
brown   7   1.8

For each row, I'd like to write a function called "fun_color" by the following format: y = a*(x^b)

(a and b are the values of the data$a and data$b column for each row. x is the domain of the function.)

I assumed I should write a nested for loop along the following:

for (i in dt$color) 
  {(paste("fun_",i, sep = "")) = function(x)
    for (a in dt$a) 
      {a*x}
    }

However, I, a relative R newbie, can't quite get this for loop to work.

I'd then like to plot each of these 10 equations on the same plot. I assume I should write another for loop here, something like:

plot(fun_red)
for (i in function_list) {
  plot(i, add=TRUE)}

Any help? Thanks!

Ah, sorry, that's supposed to be y = a*(x^b). The a and b are the values of the data$a and data$b columns. x is the domain of the function I want to write. — Jim, Aug 08 '16 at 06:01

shayaa · Accepted Answer · 2016-08-08T08:28:19.743

2

Choose a sequence of x values, and iterate over them with sapply. No need to call the plotting functions many times, just use matplot.

s <- seq(.2,5,by =.2)
matplot(s,t(sapply(s, function(x) dt$a*(x)^dt$b)),
        type = "l", lty = "solid", lwd = 2, col = dt$color, ylab = "y", xlab = "x")

edited Aug 08 '16 at 08:28

answered Aug 08 '16 at 08:20

shayaa

2,787
13
19

2

However, `matplot` is a wrapper function which uses a `for` loop internally that calls the plotting functions "many times". – Roland Aug 08 '16 at 08:51
I know, but it definitely has its benefits regarding automatic generation of the plot limits. – shayaa Aug 08 '16 at 09:00

score 0 · Answer 2 · answered Aug 08 '16 at 07:28

Yes, use a for loop. However, use curve for plotting functions.

plot.new()
plot.window(xlim = c(0, 5), ylim = c(0, 200))
for (i in seq_len(nrow(DF))) curve(DF$a[i] * (x ^ DF$b[i]), 
                                   add = TRUE, col = as.character(DF$color[i]),
                                   lwd = 2)
axis(1)  
axis(2)

Choubi · Answer 3 · 2016-08-08T09:30:20.780

0

The following does not use a for loop to create the functions but rather uses a function that returns a different function depending on the color given as argument. This has the advantage of not using assign and get.

fun_col <- function(col) {
  a <- dt$a[dt$color == col]
  b <- dt$b[dt$color == col]
  function(x) a*x^b
}

for (col in dt$color) {

  plot(fun_col(col), add = TRUE)

}

edited Aug 08 '16 at 09:30

answered Aug 08 '16 at 07:29

Choubi

640
3
9

Downvote for promoting `assign` and `get` for this. You should use a `list` instead. – Roland Aug 08 '16 at 07:35
I was going to add the list equivalent but for some reason, it gets weird, I am writing a question for clarification regarding this problem. – Choubi Aug 08 '16 at 07:40
Here is my question: http://stackoverflow.com/questions/38823761/creating-functions-in-a-for-loop-with-lists – Choubi Aug 08 '16 at 07:46
edit: I deleted the assign and get "solution" as I realised it worked mainly for the wrong reason – Choubi Aug 08 '16 at 09:30

nya · Answer 4 · 2016-08-08T09:02:56.660

Alternatively, we can plot the functions with apply rather than the for loop. First, let's read in data and the range of the values to plot.

dt <- read.table(text="color   a   b
red     3   1.3
blue    9   1.8
purple  13  1.2
green   4   1.1
orange  7   0.9
yellow  6   2.1
brown   7   1.8", header=T)

# vector for x values
x1 <- 0
x2 <- 1
n <- 100
x <- seq(x1, x2, by = ((x2-x1)/n))

Then, we plot an empty space into which the function curves will be plotted. Note, that we calculate the maximum needed for the y axis in the max.y variable.

max.y <- dt[which.max(rowSums(dt[,2:3])),2] * (x2 ^ dt[which.max(rowSums(dt[,2:3])),3])

plot(x1, type="n", xlim=c(x1,x2), ylim=c(x1, max.y), xlab="x", ylab="a*(x^b)")

And finally, we plot the lines according to the specifications in the data.

apply(dt, 1, FUN=function(dt.row) 
    lines(x, as.numeric(dt.row[2]) * (x ^ as.numeric(dt.row[3])), col=dt.row[1]))

Benchmarking

As per Roland's and shayaa's comments, here is the performance comparison. The whole answers from Roland and shayaa were fed into the respective functions, and everything from here starting from the x1 variable definition into the nya() function.

library(microbenchmark)
microbenchmark(roland(dt))
Unit: milliseconds
       expr      min      lq    mean   median       uq      max neval
 roland(dt) 18.09634 18.4124 19.2258 18.67313 19.17735 35.42943   100
microbenchmark(shayaa(dt=dt))
Unit: milliseconds
            expr      min       lq     mean   median       uq      max neval
 shayaa(dt = dt) 10.85788 11.04311 11.44358 11.22057 11.51216 18.19182   100
 microbenchmark(nya(dt=dt))
 Unit: milliseconds
          expr      min       lq     mean  median       uq      max neval
  nya(dt = dt) 18.26883 18.61892 19.02823 18.8229 19.18054 25.41353   100

I would conclude that in this case, performance is not a critical issue. The user might choose an approach based on personal preference and amend it with dynamic options for plot size (x1, x2, max.y).

`system.time` is not the way to benchmark something that takes 2 milliseconds of system time. Use `microbenchmark` instead. — shayaa, Aug 08 '16 at 08:55

R nested for loop to write multiple functions and plot them

4 Answers4

Linked