Returns the rank of this worker node.

        Returns
        -------
        rank : int
            The rank of this node, which is in range [0, num_workers())
330277
def rank(self):
        
        rank = ctypes.c_int()
        check_call(_LIB.MXKVStoreGetRank(self.handle, ctypes.byref(rank)))
        return rank.value
384113
def s(self):
		
		next_node=self._exe_order[self.step]
		self._eval(next_node)
		self.step+=1
		if self.step==len(self._exe_order):
			return self._finish()
		else:
			# if stepping, return the value of the node we just
			# evaled
			return self._break(value=self._cache.get(next_node.name))
970055
def rank_member(self, member, score, member_data=None):
        '''
        
        '''
        self.rank_member_in(self.leaderboard_name, member, score, member_data)
898713
public function rank()
    {
        $eps = pow(2.0, -52.0);
        $tol = max($this->m, $this->n) * $this->s[0] * $eps;
        $r = 0;
        for ($i = 0; $i < count($this->s); ++$i) {
            if ($this->s[$i] > $tol) {
                ++$r;
            }
        }
        return $r;
    }
104479
def rank(self, score):
        ''''''
        node = self.__head
        rank = 0
        for i in range(self.__level-1, -1, -1):
            while node.next[i] and node.next[i].score <= score:
                rank += node.width[i]
                node = node.next[i]
        if node.score == score:
            return rank - 1
        else:
            return -1 - rank
395653
public int getRunningThreadCount() {
        int rc = 0;
        WorkQueue[] ws; WorkQueue w;
        if ((ws = workQueues) != null) {
            for (int i = 1; i < ws.length; i += 2) {
                if ((w = ws[i]) != null && w.isApparentlyUnblocked())
                    ++rc;
            }
        }
        return rc;
    }
1296634
def rank(expr, sort=None, ascending=True):
    
    return _rank_op(expr, Rank, types.int64, sort=sort, ascending=ascending)
403405
public alluxio.grpc.WorkerRange getWorkerRange() {
    alluxio.grpc.WorkerRange result = alluxio.grpc.WorkerRange.valueOf(workerRange_);
    return result == null ? alluxio.grpc.WorkerRange.ALL : result;
  }
72851
def rank_members_in(self, leaderboard_name, members_and_scores):
        '''
        
        '''
        pipeline = self.redis_connection.pipeline()
        for member, score in grouper(2, members_and_scores):
            if isinstance(self.redis_connection, Redis):
                pipeline.zadd(leaderboard_name, member, score)
            else:
                pipeline.zadd(leaderboard_name, score, member)
        pipeline.execute()
537232
def is_sorted(self, ranks=None):
        
        ranks = ranks or self.ranks

        return check_sorted(self, ranks)
867401
public int rank () {
		double eps = Math.pow(2.0,-52.0);
		double tol = Math.max(m,n)*s[0]*eps;
		int r = 0;
		for (int i = 0; i < s.length; i++) {
			if (s[i] > tol) {
				r++;
			}
		}
		return r;
	}
152989
async def rank(self) -> Optional[float]:
        

        if not self.request.has_layer(l.RawText):
            return

        tl = self.request.get_layer(l.RawText)
        matcher = Matcher([
            tuple(Trigram(y) for y in x)
            for x in await self.intent.strings(self.request)
        ])

        return matcher % Trigram(tl.text)
29961
def rank():
    
    rank_data_url = 'https://raw.githubusercontent.com/Microsoft/LightGBM/master/examples/lambdarank/'
    x_train, y_train = sklearn.datasets.load_svmlight_file(cache(rank_data_url + 'rank.train'))
    x_test, y_test = sklearn.datasets.load_svmlight_file(cache(rank_data_url + 'rank.test'))
    q_train = np.loadtxt(cache(rank_data_url + 'rank.train.query'))
    q_test = np.loadtxt(cache(rank_data_url + 'rank.test.query'))
    return x_train, y_train, x_test, y_test, q_train, q_test
836011
private int rank(Key key, RedBlackTreeNode<Key, Value> x) {
	if (x == null)
	    return 0;
	int cmp = key.compareTo(x.getKey());
	if (cmp < 0)
	    return rank(key, x.getLeft());
	else if (cmp > 0)
	    return 1 + size(x.getLeft()) + rank(key, x.getRight());
	else
	    return size(x.getLeft());
    }
52463
def _job_sorting_key(self, job):
        

        MAX_BLOCKS_PER_FUNCTION = 1000000

        task_functions = list(reversed(
            list(task.function_address for task in self._task_stack if isinstance(task, FunctionAnalysis))
            ))
        try:
            function_pos = task_functions.index(job.func_addr)
        except ValueError:
            # not in the list
            # it might be because we followed the wrong path, or there is a bug in the traversal algorithm
            # anyways, do it first
            l.warning('Function address %#x is not found in task stack.', job.func_addr)
            return 0

        try:
            block_in_function_pos = self._ordered_node_addrs(job.func_addr).index(job.addr)
        except ValueError:
            # block not found. what?
            block_in_function_pos = min(job.addr - job.func_addr, MAX_BLOCKS_PER_FUNCTION - 1)

        return block_in_function_pos + MAX_BLOCKS_PER_FUNCTION * function_pos
957198
def rank(self):
        

        if self._rank != {}:
            # Don't bother doing attribute lookups again
            return self._rank

        try:
            # The eater determining the rank
            levelkey, typename, count = self.kill_eaters[0]
        except IndexError:
            # Apparently no eater available
            self._rank = None
            return None

        rankset = self._ranks.get(levelkey,
                                  [{"level": 0,
                                    "required_score": 0,
                                    "name": "Strange"}])

        for rank in rankset:
            self._rank = rank
            if count < rank["required_score"]:
                break

        return self._rank
851675
def ranked_attributes(self):
        
        matrix = javabridge.call(self.jobject, "rankedAttributes", "()[[D")
        if matrix is None:
            return None
        else:
            return arrays.double_matrix_to_ndarray(matrix)