Returns a list of howmany integers with a maximum value = max.
    The minimum value defaults to zero.
431107
def rnumlistwithreplacement(howmany, max, min=0):
    """"""
    if checkquota() < 1:
        raise Exception("Your www.random.org quota has already run out.")
    requestparam = build_request_parameterWR(howmany, min, max)
    request = urllib.request.Request(requestparam)
    request.add_header('User-Agent', 'randomwrapy/0.1 very alpha')
    opener = urllib.request.build_opener()
    numlist = opener.open(request).read()
    return numlist.split()
1032182
function range(defaultMin, defaultMax, min, max) {
  if (min === undefined) {
    return integer(defaultMin, defaultMax); // ()
  }

  if (max === undefined) {
    return min; // ( len )
  }

  return integer(min, max); // ( min, max )
}
512091
def _secondary_max(self):
        """"""
        return (
            self.secondary_range[1]
            if (self.secondary_range
                and self.secondary_range[1] is not None) else
            (max(self._secondary_values) if self._secondary_values else None)
        )
575594
def max(self):
        
        if len(self._data) == 0:
            return 600
        return next(iter(reversed(sorted(self._data.keys()))))
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"]
691077
public static <T> T max(Iterator<T> self) {
        return max((Iterable<T>)toList(self));
    }
775214
public static <T> List<T> minList (Iterable<T> iterable, Comparator<? super T> comp)
    {
        return maxList(iterable, java.util.Collections.reverseOrder(comp));
    }
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)
        )
282967
public static <T extends Comparable<? super T>> List<T> maxList (Iterable<T> iterable)
    {
        return maxList(iterable, new Comparator<T>() {
            public int compare (T o1, T o2) {
                return o1.compareTo(o2);
            }
        });
    }
650219
def max_len(iterable, minimum=0):
    
    try:
        result = max(map(len, iterable))
    except ValueError:
        result = minimum
    return minimum if result < minimum else result
1152370
def _next_lowest_integer(group_keys):
    
    try: #TODO Replace with max default value when dropping compatibility with Python < 3.4
        largest_int= max([ int(val) for val in group_keys if _is_int(val)])
    except:
        largest_int= 0
    return largest_int + 1
1309982
def get_max(array):
    
    largest = -np.inf
    for i in array:
        try:
            if i > largest:
                largest = i
        except:
            pass
    if np.isinf(largest):
        raise ValueError("there's no numeric value in array!")
    else:
        return largest
1188647
public static int whichMax(float[] x) {
        float m = Float.NEGATIVE_INFINITY;
        int which = 0;

        for (int i = 0; i < x.length; i++) {
            if (x[i] > m) {
                m = x[i];
                which = i;
            }
        }

        return which;
    }
714853
public static int getMaxValueIndex (int[] values)
    {
        if (values == null || values.length == 0) {
            return -1;
        }

        int idx = 0;
        int max = values[idx];
        for (int ii = 1; ii < values.length; ii++) {
            if (values[ii] > max) {
                max = values[ii];
                idx = ii;
            }
        }
        return idx;
    }
830231
def _max(self, memory, addr, **kwargs):
        
        return memory.state.solver.max(addr, exact=kwargs.pop('exact', self._exact), **kwargs)
1073527
public static double max(double[][] values) {
    double max = 0;
    for (int i = 0; i < values.length; i++) {
      for (int j = 0; j < values[i].length; j++) {
        max = (values[i][j] > max) ? values[i][j] : max;
      }
    }
    return max;
  }
245323
public static int max(int[][] matrix) {
    int max = Integer.MIN_VALUE;
    for (int[] row : matrix) {
      for (int elem : row) {
        max = Math.max(max, elem);
      }
    }
    return max;
  }