Return the minimum value in the histogram.
966514
public Optional<Double> max() {
        if (isEmpty()) return Optional.empty();
        return Optional.of(buckets_.get(buckets_.size() - 1).getRange().getCeil());
    }
1261113
def min_iml(self):
        
        mini = self.minimum_intensity
        if mini:
            for imt in self.imtls:
                try:
                    mini[imt] = calc.filters.getdefault(mini, imt)
                except KeyError:
                    raise ValueError(
                        'The parameter `minimum_intensity` in the job.ini '
                        'file is missing the IMT %r' % imt)
        if 'default' in mini:
            del mini['default']
        return F32([mini.get(imt, 0) for imt in self.imtls])
1357845
def get_histogram(data):
    

    count = len(data)

    if count < 2:
        raise StatisticsError('Too few data points ({}) for get_histogram'.format(count))

    min_ = data[0]
    max_ = data[-1]
    std = stdev(data)

    bins = get_histogram_bins(min_, max_, std, count)

    res = {x: 0 for x in bins}

    for value in data:
        for bin_ in bins:
            if value <= bin_:
                res[bin_] += 1
                break

    return sorted(iteritems(res))
741630
def get_minimum(self, other):
        """"""
        return Point(min(self.x, other.x), min(self.y, other.y))
546055
def min(x, y, context=None):
    
    return _apply_function_in_current_context(
        BigFloat,
        mpfr.mpfr_min,
        (
            BigFloat._implicit_convert(x),
            BigFloat._implicit_convert(y),
        ),
        context,
    )
398978
public static int min(IntTuple t)
    {
        return IntTupleFunctions.reduce(
            t, Integer.MAX_VALUE, Math::min);
    }
502109
def GetMinimum(self, expression, cut=None):
        
        if cut:
            self.Draw(expression, cut, "goff")
        else:
            self.Draw(expression, "", "goff")
        vals = self.GetV1()
        n = self.GetSelectedRows()
        vals = [vals[i] for i in range(min(n, 10000))]
        return min(vals)
742789
def min_values(args):
    
    return Interval(min(x.low for x in args), min(x.high for x in args))
1229310
def __find_smallest(self):
        """"""
        minval = sys.maxsize
        for i in range(self.n):
            for j in range(self.n):
                if (not self.row_covered[i]) and (not self.col_covered[j]):
                    if minval > self.C[i][j]:
                        minval = self.C[i][j]
        return minval
219387
public int min() {
    int min = Integer.MAX_VALUE;
    for (E key : map.keySet()) {
      min = Math.min(min, getIntCount(key));
    }
    return min;
  }
468506
def _get_smallest_dimensions(self, data):
        """"""
        min_width = 0
        min_height = 0
        for element in self.elements:
            if not element: continue
            size = element.get_minimum_size(data)
            min_width = max(min_width, size.x)
            min_height = max(min_height, size.y)
        return datatypes.Point(min_width, min_height)
148280
def minimum(self, value):
        
        self._remove_min()
        if value is None:
            return
        self._add_min(val=value)
1196649
def tail_threshold(vals, N=1000):
    """"""
    vals = numpy.array(vals)
    if len(vals) < N:
        raise RuntimeError('Not enough input values to determine threshold')
    vals.sort()
    return min(vals[-N:])
148579
def min(self):
        
        if len(self._data) == 0:
            return 10
        return next(iter(sorted(self._data.keys())))
700057
def get_bbox(self):
        """"""

        x_min = self.x
        x_max = x_min + self.width
        y_min = self.y
        y_max = self.y + self.height

        return x_min, x_max, y_min, y_max
614104
public static int min( GrayS32 input ) {
		if( BoofConcurrency.USE_CONCURRENT ) {
			return ImplImageStatistics_MT.min(input.data, input.startIndex, input.height, input.width , input.stride);
		} else {
			return ImplImageStatistics.min(input.data, input.startIndex, input.height, input.width , input.stride);
		}
	}
673682
def minimum( self ):
        
        if ( self._minimum is not None ):
            return self._minimum
        
        rtype = self.rulerType()
        
        if ( rtype == XChartRuler.Type.Number ):
            self._minimum = 0
            
        elif ( rtype == XChartRuler.Type.Date ):
            self._minimum = QDate.currentDate()
        
        elif ( rtype == XChartRuler.Type.Datetime ):
            self._minimum = QDateTime.currentDateTime()
        
        elif ( rtype == XChartRuler.Type.Time ):
            self._minimum = QDateTime.currentDateTime().time()
        
        else:
            notches = self.notches()
            if ( notches ):
                self._minimum = notches[0]
        
        return self._minimum