Any reduction op.
482918
def Any(a, axis, keep_dims):
    
    return np.any(a, axis=axis if not isinstance(axis, np.ndarray) else tuple(axis),
                  keepdims=keep_dims),
793493
function (op) {
  return function(condition) {
    return this._compare(function(val) {
      var isNum = _.isNumber(val);
      switch (op) {
        case 'gt':
          return isNum && val > condition;
        case 'lt':
          return isNum && val < condition;
        case 'gte':
          return isNum && val >= condition;
        default:
          return isNum && val <= condition;
      }
    });
  };
}
113304
function reduce(options, params, location, program) {
    return options.every? new reduce_every(options, params, location, program) : new reduce_batch(options, params, location, program);
}
170715
function reduce (obj, cb, initial, ctx)
{
    var acc = initial;
    for(var key in obj)
        acc = cb.call(ctx, acc, key, obj[key]);
    return acc;
}
1187335
def reduce_min(attrs, inputs, proto_obj):
    """"""
    new_attrs = translation_utils._fix_attribute_names(attrs, {'axes':'axis'})
    return 'min', new_attrs, inputs
1000073
def _allowed(to_op, from_op, rhs):
    ""
    if is_none(rhs):
        return to_op in _RHS_IS_NONE_OPS.get(from_op, ())

    if is_number(rhs):
        return to_op in _RHS_IS_INTEGER_OPS

    return True
1366427
def _le_from_ge(self, other):
    """"""
    op_result = self.__ge__(other)
    if op_result is NotImplemented:
        return NotImplemented
    return not op_result or self == other
1044727
def reduce(self, agg=operator.add, acc=None):
        
        return self.submit_all().reduce(agg, acc)
1197606
def _bld_op(self, op, num, **kwargs):
        """"""
        kwargs['other'] = num        
        setattr(self, op, {'mtype': pab, 'kwargs': kwargs})
1153982
def _opdist_low(av, bv, cv, deriv):
    """"""
    a = Vector3(9, deriv, av, (0, 1, 2))
    b = Vector3(9, deriv, bv, (3, 4, 5))
    c = Vector3(9, deriv, cv, (6, 7, 8))
    n  = cross(a, b)
    n /= n.norm()
    dist = dot(c, n)
    return dist.results()
973416
def _ge_from_gt(self, other):
    """"""
    op_result = self.__gt__(other)
    return op_result or self == other
991397
private boolean reducing() {
        if (this.limits.reduceRedundant == 0) { this.limits.reduceRedundant = this.config.redinit; }
        long limit = this.limits.reduceRedundant;
        limit += this.limits.reduceForcing;
        limit += this.limits.reduceImportant;
        return limit <= this.stats.clausesRedundant;
    }
1022111
def relation_operation(self):
        
        if len(self.nodes) > 0:
            rel_op = self.nodes[-1].relation_operation
        else:
            rel_op = None
        return rel_op
295522
def _op_maker(op_class, op_symbol):
    

    def f(self, node, *args, **kwargs):
        """Return a partial function with an Op subclass with an operator
        already passed.

        Returns
        -------
        f : callable
        """
        return partial(op_class, op_symbol, *args, **kwargs)
    return f
785196
def op_at_on(operation: ops.Operation,
                 time: Timestamp,
                 device: Device):
        """"""
        return ScheduledOperation(time,
                                  device.duration_of(operation),
                                  operation)
473561
function any(arr, contition) {
  let result = false;

  util.forEach(arr, item => {
    result = contition(item);

    return !result;
  });

  return result;
}
178373
function reducer(individualSeries, initialFunction, reductionFunction) {
                        if (individualSeries.length == 0) {
                            return NaN;
                        }
                        var initial = initialFunction(individualSeries[0][1]);
                        var i=1;
                        for (; initial==null && i<individualSeries.length; i++) {
                            initial = initialFunction(individualSeries[i][1]);
                        }
                        for (; i<individualSeries.length; i++) {
                            if (individualSeries[i][1] != null) {
                                initial = reductionFunction(initial, individualSeries[i][1]);
                            }
                        }
                        return initial;
                    }