reduce

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]) (when consistent = false)

or

reduce:TC(X, [init]) (when consistent = true)

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.

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 for more information.

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

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 for X times
reduce(func1, 5, 1)
// output
18

// when X is a unary function condition, the 3rd iteration stops as the condition returns false
def condition(x){
  return x<9
}
reduce(func1, condition, 1)
// output
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 result
reduce(func2,NULL,1)
// output
6

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

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

// 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;

+ :T x;
// output
[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)
// output
41