-> #float :func:numpy.max of the timing intervals
763292
def max(self):
        
        return round(np.max(self.array), self.precision)\
            if len(self.array) else None
524558
def is_in_intervall(value, min_value, max_value, name='variable'):
    
    if not (min_value <= value <= max_value):
        raise ValueError('{}={} is not in [{}, {}]'
                         .format(name, value, min_value, max_value))
288022
def get_stride(self):
        
        fftlength = float(self.args.secpfft)
        overlap = fftlength * self.args.overlap
        stride = fftlength - overlap
        nfft = self.duration / stride  # number of FFTs
        ffps = int(nfft / (self.width * 0.8))  # FFTs per second
        if ffps > 3:
            return max(2 * fftlength, ffps * stride + fftlength - 1)
        return None
154073
def scale_between(minval, maxval, numStops):
    

    scale = []

    if numStops < 2:
        return [minval, maxval]
    elif maxval < minval:
        raise ValueError()
    else:
        domain = maxval - minval
        interval = float(domain) / float(numStops)
        for i in range(numStops):
            scale.append(round(minval + interval * i, 2))
        return scale
392649
def max_time_last
      max = 0
      i = 0
      while i < @children.size
        tl = @children[i].time_last
        max = tl if tl > max
        i += 1
      end
      max
    end
762666
def intervals(_min, _max=None, size=1):
    
    if _max == None:
        _max = _min
        _min = 0
    _max = int(mo_math.ceiling(_max))
    _min = int(mo_math.floor(_min))

    output = ((x, min(x + size, _max)) for x in _range(_min, _max, size))
    return output
742789
def min_values(args):
    
    return Interval(min(x.low for x in args), min(x.high for x in args))
339973
def max(self):
        
        results = [x.ufuncs.max() for x in self.elem]
        return np.max(results)
88160
def _maxlength(X):
    
    return np.fromiter((map(lambda x: len(x), X)), dtype=int).max()
997968
def try_ntime(max_try, func, *args, **kwargs):
    
    if max_try < 1:
        raise ValueError

    for i in range(max_try):
        try:
            return func(*args, **kwargs)
        except Exception as e:
            last_exception = e

    raise last_exception
83788
def max_or_none(val1, val2):
    """"""
    return max(val1, val2, key=lambda x: -sys.maxint if x is None else x)
420864
def max(self):
        """"""
        if "max" not in self.attrs.keys():

            def f(dataset, s):
                return np.nanmax(dataset[s])

            self.attrs["max"] = np.nanmax(list(self.chunkwise(f).values()))
        return self.attrs["max"]
391633
def findMax(arr):
    
    out = np.zeros(shape=arr.shape, dtype=bool)
    _calcMax(arr, out)
    return out
670942
def end_datetime(self) -> Optional[datetime.datetime]:
        
        if not self.intervals:
            return None
        return max([x.end for x in self.intervals])
885941
def _max(self):
        """"""
        return (
            self.range[1] if (self.range and self.range[1] is not None) else
            (max(self.yvals) if self.yvals else None)
        )
1312476
def global_max(col_vals, index):
    """"""
    col_vals_without_None = [x for x in col_vals if x is not None]
    max_col, min_col = zip(*col_vals_without_None)
    return max(max_col), min(min_col)
1113940
def prox_max(X, step, thresh=0):
    
    thresh_ = _step_gamma(step, thresh)
    above = X - thresh_ > 0
    X[above] = thresh_
    return X