# cross (:C)/pcross

**Syntax**

cross(func, X, [Y])

or

X <operator>:C Y

**Arguments**

func is a binary function.

X and Y can be pair/vector/matrix. They can have different data forms and sizes.

Y is optional. If Y is not specified, perform cross(func, X, X) where func must be a symmetric binary function, such as corr .

**Details**

Apply func to the permutation of all individual elements of *X* and *Y* and return a matrix.

Assume X has m elements and Y has n elements. The template returns an m (rows) by n (columns) matrix. Below is the pseudo code for the `cross`

template.

```
for(i:0~(size(X)-1)){
for(j:0~(size(Y)-1)){
result[i,j]=<function>(X[i], Y[j]);
}
}
return result;
```

If *X* and *Y* are matrices, the iteration is over the columns of *X* and *Y* .

If the result of func(X[i], Y[j]) is a scalar, the result of the `cross`

template is a matrix.

If the result of func(X[i], Y[j]) is a vector, the result of the `cross`

template is a tuple with m elements. Each of the element is a tuple with n elements.

`pcross`

is the parallel computing version of template function `cross`

.

**Examples**

`cross`

with two vectors:

```
$ x=1 2;
$ y=3 5 7;
$ x+:C y;
```

lable |
3 |
5 |
7 |
---|---|---|---|

1 |
4 |
6 |
8 |

2 |
5 |
7 |
9 |

```
$ cross(mul, x, y);
```

lable |
3 |
5 |
7 |
---|---|---|---|

1 |
3 |
5 |
7 |

2 |
6 |
10 |
14 |

```
$ cross(pow, x, y);
```

lable |
3 |
5 |
7 |
---|---|---|---|

1 |
1 |
1 |
1 |

2 |
8 |
32 |
128 |

`cross`

with two matrices:

```
$ m = 1..6$2:3;
$ m;
```

clo1 |
col2 |
col3 |
---|---|---|

1 |
3 |
5 |

2 |
4 |
6 |

```
$ n=1..4$2:2;
$ n;
```

clo1 |
col2 |
---|---|

1 |
3 |

2 |
4 |

```
$ cross(**, m, n);
```

clo1 |
col2 |
---|---|

5 |
11 |

11 |
25 |

17 |
39 |

`cross`

with a vector and a matrix:

```
$ def topsum(x,n){return sum x[0:n]};
$ a=1..18$6:3;
$ a;
```

clo1 |
col2 |
col3 |
---|---|---|

1 |
7 |
13 |

2 |
8 |
14 |

3 |
9 |
15 |

4 |
10 |
16 |

5 |
11 |
17 |

6 |
12 |
18 |

```
$ b=2 4;
$ a topsum :C b;
```

2 |
4 |
---|---|

3 |
10 |

15 |
34 |

27 |
58 |

`cross`

with tuple type results:

```
$ x=1 2
$ y=1..6$2:3
$ cross(add, x, y);
(([2,3],[4,5],[6,7]),([3,4],[5,6],[7,8]))
$ x=1 2
$ y=1..6$3:2
$ cross(add, x, y);
(([2,3,4],[5,6,7]),([3,4,5],[6,7,8]))
```