Get the maximal value of interval index among the nodes
549680
public function getCurrentMax()
	{
		$max = 0;
		/* @var $node Node\NodeInterface */
		foreach ($this->array as $node) {
			$max = max($max, $node->getRightValue());
		}
		return $max;
	}
105756
def max_interval_intersec(S):
    
    B = ([(left,  +1) for left, right in S] +
         [(right, -1) for left, right in S])
    B.sort()
    c = 0
    best = (c, None)
    for x, d in B:
        c += d
        if best[0] < c:
            best = (c, x)
    return best
248763
def max(self, axis=None, skipna=True):
        """"""
        nv.validate_minmax_axis(axis)
        return self._minmax('max')
1194304
def max(self, axis=None, dtype=None, out=None, keepdims=False):
        
        return self.elem.__array_ufunc__(
            np.maximum, 'reduce', self.elem,
            axis=axis, dtype=dtype, out=(out,), keepdims=keepdims)
1276997
def max_values(args):
    
    return Interval(max(x.low for x in args), max(x.high for x in args))
813080
def get_minmax(self, stmt, refine_dict):
        
        minel = refine_dict["min-elements"]
        maxel = refine_dict["max-elements"]
        if minel is None:
            minst = stmt.search_one("min-elements")
            if minst:
                minel = minst.arg
            else:
                minel = "0"
        if maxel is None:
            maxst = stmt.search_one("max-elements")
            if maxst:
                maxel = maxst.arg
        if maxel == "unbounded": maxel = None
        return (minel, maxel)
119127
def diameter(self):
        '''
        '''
        d = dict(); best = float('-inf')
        for node in self.traverse_postorder():
            if node.is_leaf():
                d[node] = 0
            else:
                dists = sorted(d[c]+c.edge_length for c in node.children)
                d[node] = dists[-1]; max_pair = dists[-1]+dists[-2]
                if max_pair > best:
                    best = max_pair
        return best
1279841
public NodeAVL getNode(int index) {

        NodeAVL n = nPrimaryNode;

        while (index-- > 0) {
            n = n.nNext;
        }

        return n;
    }
92475
public static INDArrayIndex interval(long begin, long stride, long end,long max) {
        if(begin < 0) {
            begin += max;
        }

        if(end < 0) {
            end += max;
        }

        if (Math.abs(begin - end) < 1)
            end++;
        if (stride > 1 && Math.abs(begin - end) == 1) {
            end *= stride;
        }
        return interval(begin, stride, end, false);
    }
868280
function get_highest_val (node, prop) {
    var highest = 0;
    node.apply(function (n) {
        if (species_data[n.node_name()] === undefined) {
            return;
        }
        var val = parseFloat(species_data[n.node_name()][prop]);
        if (val > highest) {
            highest = val;
        }
    });
    return highest;
}
36144
def get_most_specific_tinfo(goids, go2nt):
    """"""
    # go2nt_usr = {go:go2nt[go] for go in goids}
    # return max(go2nt_usr.items(), key=lambda t: t[1].tinfo)[0]
    return max(_get_go2nt(goids, go2nt), key=lambda t: t[1].tinfo)[0]
1130572
def eigenvalue(nodes, node=None):
    
    if node is None:
        return sorted([eigenvalue(nodes, n) for n in nodes])[0]  # return lowest eigenvalue
    else:
        return len([1 for n in nodes if hops(node, n)])
193482
def max_order(self):
        
        # TODO: cache value
        combo = int(0)
        for iv in self._interval_set._intervals:
            combo |= iv[0] | iv[1]

        ret = AbstractMOC.HPY_MAX_NORDER - (utils.number_trailing_zeros(combo) // 2)
        if ret < 0:
            ret = 0

        return ret
859572
def max(self):
        
        return self._constructor(self.values.max(axis=self.baseaxes, keepdims=True))
1166360
def get_max_value_key(dic):
    """"""
    v = np.array(list(dic.values()))
    k = np.array(list(dic.keys()))

    maxima = np.where(v == np.max(v))[0]
    if len(maxima) == 1:
        return k[maxima[0]]
    else:
        # In order to be consistent, always selects the minimum key
        # (guaranteed to be unique) when there are multiple maximum values.
        return k[maxima[np.argmin(k[maxima])]]
256313
def maximum(self, node):
        
        temp_node = node
        while temp_node.right is not None:
            temp_node = temp_node.right
        return temp_node
343079
private static long findMaxTime(Node n) {
        long max = Long.MIN_VALUE;
        for (Map.Entry<String, Node> entry : n.children.entrySet()) {
            max = Math.max(max, entry.getValue().time);
        }
        return max;
    }