Returns the max value of data elements
        :param func: lambda expression to transform data
        :return: maximum value
184390
def max(self, func=lambda x: x):
        
        if self.count() == 0:
            raise NoElementsError(u"Iterable contains no elements")
        return max(self.select(func))
1259657
def _aggregate_func(self, aggregate):
        
        funcs = {"sum": add, "min": min, "max": max}
        func_name = aggregate.lower() if aggregate else 'sum'
        try:
            return funcs[func_name]
        except KeyError:
            raise TypeError("Unsupported aggregate: {}".format(aggregate))
522243
def all(self, func):
        
        return all([func(k, v) for k, v in self.items()])
1035103
def max(self, key=None):
        

        def _max(result, item):
            val = data_get(item, key)

            if result is None or val > result:
                return value

            return result

        return self.reduce(_max)
423526
function getValueReturnedInFirstStatement(func) {
    const firstLine = getFirstFunctionLine(func)
    if (func) {
        if (isFunctionDefinitionWithBlock(func)) {
            return isReturnStatement(firstLine) ? firstLine.argument : undefined
        }
        if (func.type === 'ArrowFunctionExpression') {
            return firstLine
        }
    }
}
1276997
def max_values(args):
    
    return Interval(max(x.low for x in args), max(x.high for x in args))
1054814
def _wrapper(self, func):
        
        def wrapped(*args, **kwargs):
            ret_val = func(*args, **kwargs)
            if isinstance(ret_val, pymongo.cursor.Cursor):
                ret_val = self.from_cursor(ret_val)
            return ret_val

        return wrapped
464018
function detectValue (min, max) {
	return getTransformer(function (a, b) {
		return (a + b) * 0.5;
	})(min, max);
}
492372
def _max(self):
        """"""
        return (
            self.range[1] if (self.range and self.range[1] is not None) else
            (max(map(abs, self._values)) if self._values else None)
        )
324882
def _nan_argminmax_object(func, fill_value, value, axis=None, **kwargs):
    
    valid_count = count(value, axis=axis)
    value = fillna(value, fill_value)
    data = _dask_or_eager_func(func)(value, axis=axis, **kwargs)

    # TODO This will evaluate dask arrays and might be costly.
    if (valid_count == 0).any():
        raise ValueError('All-NaN slice encountered')

    return data
136242
def find(self, func: Callable[[K, T], bool]) -> TOption[T]:
        
        for k, v in self.items():
            if func(k, v):
                return TOption(v)
        return TOption(None)
575594
def max(self):
        
        if len(self._data) == 0:
            return 600
        return next(iter(reversed(sorted(self._data.keys()))))
1331373
def maximum(self, value):
        
        self._remove_max()
        if value is None:
            return
        self._add_max(val=value)
896242
def MAX(values, *others):
    

    if others:
        from mo_logs import Log
        Log.warning("Calling wrong")
        return MAX([values] + list(others))

    output = Null
    for v in values:
        if v == None:
            continue
        elif output == None or v > output:
            output = v
        else:
            pass
    return output
1295524
def transform(self, func):
        
        if func.__code__.co_argcount == 1:
            one_arg_func = func
            func = lambda _, rdd: one_arg_func(rdd)

        return TransformedDStream(self, func)
1061493
def max_value_length(cls):
        
        if not hasattr(cls, '__max_value_length_'):
            cls.__max_value_length_ = max([len(c.value) for c in list(cls)])
        return cls.__max_value_length_
456201
public <T extends Comparable<T>> Stream<TrieNode> max(Function<TrieNode, T> fn, int maxResults) {
    return max(fn, maxResults, root());
  }