# reduce (:T)

Syntax

reduce(func, X, [init], [consistent=false])

or

[init] <operator>:T X (when consistent = false)

or

[init] <operator>:TC X (when consistent = true)

or

reduce:T(X, [init], [consistent=false])

Arguments

func is a binary function.

• When func is a unary function, X can be a non-negative integer, a unary function, or a NULL value. init must be specified, which is the parameter of func.

• When func is a binary function, X can be vector/matrix/table. init is the initial value.

• When func is a ternary function, X must be a tuple with 2 elements, representing the last two parameters of func.

consistent is a Boolean value. The default value is false, indicating that the data type of the result is determined by each calculation result. Otherwise, the data type of the result is the same as the data type of the first calculation result. Note that if the data forms of each result are inconsistent, consistent can only be specified as false. Otherwise, an error will be reported.

Details

The function of `reduce` is the same as `accumulate`. Unlike the template `accumulate` that returns result of each iteration, the template `reduce` outputs only the last result. Refer to  accumulate (:A) for more information.

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

Examples

When func is a unary function:

``` // define a unary function
\$ def func1(x){
\$   if(x<5){
\$           return x*3
\$   }
\$   else{
\$           return x+3
\$   }
\$ }
// When X is an integer, iterate X times and output the last result.
\$ reduce(func1, 5, 1)
18
//X is a unary function "condition". As condition returns false during the 3rd iteration, the system stops iteration and outputs the results of the first two iterations.
\$ def condition(x){
\$   return x<9
\$ }
\$ reduce(func1, condition, 1)
9

//when X is NULL or unspecified, define a UDF func2 for iteration.
\$ def func2(x){
\$ if(x<5){
\$         return x*3
\$ }
\$ else{
\$         return 6
\$ }
\$ }
//As the results of the 3rd and 4th iterations are the same, the function stops iteration and outputs the results of the first three iterations.
\$ reduce(func2,NULL,1)
// output
6
```

When func is a binary function, and X is a vector:

```\$ reduce(mul, 1..10);
3628800
// factorization of 10

// the corresponding accumulate template for the operation above
\$ *:A 1..10;
[1,2,6,24,120,720,5040,40320,362880,3628800]

\$ 2 *:T 1..10;
7257600

\$ def f1(a,b):a+log(b);
\$ reduce(f1, 1..5, 0);
4.787492
```

`reduce` on a matrix:

```\$ x=1..12\$3:4;
\$ x;
```

col1

col2

col3

col4

1

4

7

10

2

5

8

11

3

6

9

12

```\$ + :T x;
[22,26,30]
```

When func is a ternary function:

```\$ def fun3(x,y,z){
\$   return x+y+z
\$ }
\$ reduce(fun3,[[1,2,3],[10,10,10]],5)
41
```