# each (:E) / peach

**Syntax**

or

or

**Arguments**

func is a function.

args … are the required parameters of func.

X / Y can be scalar/vector/matrix/table.

**Details**

Apply a function to each element of args…. For matrices, apply a function to each column; for tables, apply a function to each row.

The difference between *func(X)* and *func :E X* is that the former treats *X* as the one input variable while the later takes each element in *X* as an input variable. We should avoid using “:E” if we can find corresponding vector functions since element-wise operations are very slow with a large number of elements.

`peach`

is the parallel computing version of template function `each`

. For tasks that take a long time to finish, `peach`

can save a significant amount of time over `each`

. For light tasks, however, `peach`

may take longer than each as the overhead of parallel function call is not trivial.

**Examples**

Suppose we need to calculate the daily compensation for 3 workers. Their working hours are stored in vector x=[9,6,8]. Their hourly rate is \(10 under 8 hours and \)20 beyond 8 hours. Consider the following function `wage`

:

```
$ x=[9,6,8]
$ def wage(x){if(x<=8) return 10*x; else return 20*x-80}
$ wage x;
The vector can't be converted to bool scalar.
```

*wage(x)* does not return a result, as x<=8, i.e., [9,6,8]<=8 returns a vector of conditions [0,1,1], not a scalar condition that is required by `if`

.

In contrast, consider the following solutions:

```
$ each(wage, x);
[100,60,80]
$ wage :E x;
[100,60,80]
$ def wage2(x){return iif(x<=8, 10*x, 20*x-80)};
// the iif function is an element-wise conditional operation
$ wage2(x);
[100,60,80]
```

Similarly, `each`

can also be applied to a function with more than one parameter.

```
$ def addeven(x,y){if (x%2==0) return x+y; else return 0}
$ x1=1 2 3
$ x2=4 5 6;
$ each(addeven, x1, x2);
[0,7,0]
```

`each`

with a tuple:

```
$ t = table(1 2 3 as id, 4 5 6 as value, `IBM`MSFT`GOOG as name);
$ t;
```

id |
value |
name |
---|---|---|

1 |
4 |
IBM |

2 |
5 |
MSFT |

3 |
6 |
GOOG |

```
$ each(max, t[`id`value]);
[3,6]
```

`each`

with matrices:

```
$ m=1..12$4:3;
$ m;
```

col1 |
col2 |
col3 |
---|---|---|

1 |
5 |
9 |

2 |
6 |
10 |

3 |
7 |
11 |

4 |
8 |
12 |

```
$ each(add{1 2 3 4}, m);
// note add{1 2 3 4} is a partial application, which adds [1, 2, 3, 4] to each of the 3 columns
```

col1 |
col2 |
col3 |
---|---|---|

2 |
6 |
10 |

4 |
8 |
12 |

6 |
10 |
14 |

8 |
12 |
16 |

```
$ x=1..6$2:3;
$ y=6..1$2:3;
$ x;
```

col1 |
col2 |
col3 |
---|---|---|

1 |
3 |
5 |

2 |
4 |
6 |

```
$ y;
```

col1 |
col2 |
col3 |
---|---|---|

6 |
4 |
2 |

5 |
3 |
1 |

```
$ each(**, x, y);
[16,24,16]
// 比如，24=3*4+4*3
```

In the example below, we use the function `call`

in a partial application that applies each of [sin, log] to vector 1..3

```
// when "functionName" is empty, it will be filled with function names dynamically.
$ each(call{, 1..3},(sin,log));
```

sin |
log |
---|---|

0.841471 |
0 |

0.909297 |
0.693147 |

0.14112 |
1.098612 |

Performance Note

Template `:E (each)`

is not recommended when there is a large number of elements. In those scenarios we should look for more efficient vector solutions.

```
$ x=rand(16, 1000000);
$ timer(10){each(wage, x)};
Time elapsed: 38164.9 ms
$ timer(10){iif(x<8,10*x,20*x-80)};
Time elapsed: 81.516 ms
```