Getter for the minimum series value
14744
def _min(self):
        """"""
        return (
            self.range[0] if (self.range and self.range[0] is not None) else
            (min(self._values) if self._values else None)
        )
636904
def get_value(self, series, key):
        

        # if we have something that is Index-like, then
        # use this, e.g. DatetimeIndex
        # Things like `Series._get_value` (via .at) pass the EA directly here.
        s = getattr(series, '_values', series)
        if isinstance(s, (ExtensionArray, Index)) and is_scalar(key):
            # GH 20882, 21257
            # Unify Index and ExtensionArray treatment
            # First try to convert the key to a location
            # If that fails, raise a KeyError if an integer
            # index, otherwise, see if key is an integer, and
            # try that
            try:
                iloc = self.get_loc(key)
                return s[iloc]
            except KeyError:
                if (len(self) > 0 and
                        (self.holds_integer() or self.is_boolean())):
                    raise
                elif is_integer(key):
                    return s[key]

        s = com.values_from_object(series)
        k = com.values_from_object(key)

        k = self._convert_scalar_indexer(k, kind='getitem')
        try:
            return self._engine.get_value(s, k,
                                          tz=getattr(series.dtype, 'tz', None))
        except KeyError as e1:
            if len(self) > 0 and (self.holds_integer() or self.is_boolean()):
                raise

            try:
                return libindex.get_value_box(s, key)
            except IndexError:
                raise
            except TypeError:
                # generator/iterator-like
                if is_iterator(key):
                    raise InvalidIndexError(key)
                else:
                    raise e1
            except Exception:  # pragma: no cover
                raise e1
        except TypeError:
            # python 3
            if is_scalar(key):  # pragma: no cover
                raise IndexError(key)
            raise InvalidIndexError(key)
741630
def get_minimum(self, other):
        """"""
        return Point(min(self.x, other.x), min(self.y, other.y))
431179
def min(self, axis=None, skipna=True):
        """"""
        nv.validate_minmax_axis(axis)
        return self._minmax('min')
591885
function getFractionalValue(legendHelper, value) {
  var extremes = getExtremes(
    legendHelper.tableColumn,
    legendHelper.tableColumnStyle
  );
  var f =
    extremes.maximum === extremes.minimum
      ? 0
      : (value - extremes.minimum) / (extremes.maximum - extremes.minimum);
  if (legendHelper.tableColumnStyle.clampDisplayValue) {
    f = Math.max(0.0, Math.min(1.0, f));
  }
  return f;
}
1150817
def min_abs(self):
        ''''''
        if self.__len__() == 0:
            return ArgumentError('empty set has no minimum absolute value.')
        if self.contains(0):
            return 0
        return numpy.min([numpy.abs(val)
                          for val in [self.max_neg(), self.min_pos()]
                          if val is not None])
289617
def get(self, key):
        ''''''
        if key in self and len(self[key]) > 0:
            return min(self[key])
        else:
            return 0
373081
public float min(float... values) {
        float min = Float.MAX_VALUE;
        for (int i = 0; i < values.length; i++) {
            if (i == 0 || values[i] < min) {
                min = values[i];
            }
        }
        
        return min;
    }
1192544
function minBy (valueComputer, list) {
    var
      idx = 0,
      winner = list[idx],
      computedWinner = valueComputer(winner),

      computedCurrent;

    while (++idx < list.length) {
      computedCurrent = valueComputer(list[idx]);

      if (computedCurrent < computedWinner) {
        computedWinner = computedCurrent;
        winner = list[idx];
      }
    }

    return winner;
  }
806477
public static <T> Collector<T, ?, Optional<T>> min(Comparator<? super T> comparator) {
        return minBy(t -> t, comparator);
    }
742789
def min_values(args):
    
    return Interval(min(x.low for x in args), min(x.high for x in args))
188468
@Pure
	public static float min(float... values) {
		if (values == null || values.length == 0) {
			return Float.NaN;
		}
		float min = values[0];
		for (final float v : values) {
			if (v < min) {
				min = v;
			}
		}
		return min;
	}
1166964
function minV(v) {
         return this._set(this.x < v.x ? this.x : v.x, this.y < v.y ? this.y : v.y);
       }
1048746
def _values(self):
        """"""
        return [
            val[1] for serie in self.series for val in
            (serie.interpolated if self.interpolate else serie.points)
            if val[1] is not None and (not self.logarithmic or val[1] > 0)
        ]
216141
def min(self):
        
        res = self._qexec("min(%s)" % self._name)
        if len(res) > 0:
            self._min = res[0][0]
        return self._min
109635
private float MIN(float first, float second, float third) {

        float min = Integer.MAX_VALUE;
        if (first < min) {
            min = first;
        }
        if (second < min) {
            min = second;
        }
        if (third < min) {
            min = third;
        }
        return min;
    }
1233954
def min_value(self):
        

        if self._is_completely_masked:
            return np.nan * self._data_unit
        else:
            return np.min(self.values)