Get the predicate in this prediction.
353518
def get_predicate_text(sent_tokens: List[Token], tags: List[str]) -> str:
    
    return " ".join([sent_tokens[pred_id].text
                     for pred_id in get_predicate_indices(tags)])
1079307
public Gather<T> filterAsGather(Predicate<T> decision) {
		return from(Collections2.filter(elements.get(), decision));
	}
1235529
public static <T> Predicate<T> trueInstance ()
    {
        @SuppressWarnings("unchecked") Predicate<T> pred = (Predicate<T>)TRUE_INSTANCE;
        return pred;
    }
315394
public static <T> T find(T[] array, Predicate<T> predicate){
        if(array == null){
            return null;
        }
        for(T t: array){
            if(predicate.apply(t)){
                return t;
            }
        }
        return null;
    }
128302
def predicates(G: Graph, n: Node) -> Set[TriplePredicate]:
    
    return predicatesOut(G, n) | predicatesIn(G, n)
805969
public static <T> Predicate<T> falseInstance ()
    {
        @SuppressWarnings("unchecked") Predicate<T> pred = (Predicate<T>)FALSE_INSTANCE;
        return pred;
    }
596715
public Gather<T> dropWhile(final Predicate<T> predicate) {
    	final Iterator<T> it = each().iterator();
        return from(new AbstractIterator<T>() {
            private boolean done = false;
            protected T computeNext() {
                if (!done) {
                    while (it.hasNext()) {
                        T t = it.next();
                        if (!predicate.apply(t)) {
                            done = true;
                            return t;
                        }
                    }
                }
                if (it.hasNext()) {
                    return it.next();
                }
                else {
                    return endOfData();
                }
            }
        });
    }
707170
public boolean is(MatrixPredicate predicate) {
        MatrixIterator it = iterator();
        boolean result = predicate.test(rows, columns);

        while (it.hasNext() && result) {
            double x = it.next();
            int i = it.rowIndex();
            int j = it.columnIndex();
            result = predicate.test(i, j, x);
        }

        return result;
    }
1293257
function AndOrPredicate(op, preds) {
      this.op = this._resolveOp(op);
      if (preds.length == 1 && Array.isArray(preds[0])) {
        preds = preds[0];
      }
      this.preds = preds.filter(function (pred) {
        return pred != null;
      }).map(function (pred) {
        return Predicate(pred);
      });
      if (this.preds.length == 0) {
        // marker for an empty predicate
        this.op = null;
      }
      if (this.preds.length == 1) {
        return this.preds[0];
      }
    }
1331870
def klass_from_predicate(predicate)
      field_name = field_from_predicate(predicate)
      return unless field_name

      relation = relations[field_name]
      return unless relation

      relation.class_name.constantize
    end
843724
def predict(self, X):
        
        X = np.atleast_2d(X)
        m = np.empty(shape=(0,1))
        s = np.empty(shape=(0,1))

        for k in range(X.shape[0]):
            preds = []
            for pred in self.model.estimators_:
                preds.append(pred.predict(X[k,:])[0])
            m = np.vstack((m ,np.array(preds).mean()))
            s = np.vstack((s ,np.array(preds).std()))
        return m, s
413505
public synchronized int getPredictedTotal(T predicted) {
        int total = 0;
        for (T actual : classes) {
            total += getCount(actual, predicted);
        }
        return total;
    }
126321
def findall_with_pred(predicate, prs):
    
    return sorted((p for p in prs if predicate(p)),
                  key=operator.methodcaller("priority"), reverse=True)
599881
private static int getPredefinedRelation_(String scl, int dim_a, int dim_b) {
		if (equals_(scl))
			return RelationalOperations.Relation.equals;

		if (disjoint_(scl))
			return RelationalOperations.Relation.disjoint;

		if (touches_(scl, dim_a, dim_b))
			return RelationalOperations.Relation.touches;

		if (crosses_(scl, dim_a, dim_b))
			return RelationalOperations.Relation.crosses;

		if (contains_(scl))
			return RelationalOperations.Relation.contains;

		if (overlaps_(scl, dim_a, dim_b))
			return RelationalOperations.Relation.overlaps;

		return RelationalOperations.Relation.unknown;
	}
843970
def predicates(graph):
    
    seen = set()

    def _traverse(binding):
        if binding.path in seen:
            return
        seen.add(binding.path)

        if binding.is_object:
            for prop in binding.properties:
                yield (binding.path, prop.name, tuple(prop.types))
                for pred in _traverse(prop):
                    yield pred
        elif binding.is_array:
            for item in binding.items:
                for pred in _traverse(item):
                    yield pred

    schemas = graph.aliases.values()
    schemas.extend(graph.resolver.store)
    for schema_uri in graph.aliases.values():
        binding = graph.get_binding(schema_uri, None)
        for pred in _traverse(binding):
            if pred not in seen:
                yield pred
                seen.add(pred)
308540
def p_filter_expr_predicate(p):
    
    if not hasattr(p[1], 'append_predicate'):
        p[1] = ast.PredicatedExpression(p[1])
    p[1].append_predicate(p[2])
    p[0] = p[1]
240441
public float[] predict( Map<String, Double> row, double data[], float preds[] ) {
    return predict(map(row,data),preds);
  }