/*
Documented, #pick
519233
@SuppressWarnings("unchecked")
    public static <K, V> List<Tuple<K, V>> pick(final Map<K, V> object, final K ... keys) {
        return without(map(newArrayList(object.entrySet()), new Function<Map.Entry<K, V>, Tuple<K, V>>() {
            @Override
            public Tuple<K, V> apply(Map.Entry<K, V> entry) {
                if (Arrays.asList(keys).contains(entry.getKey())) {
                    return Tuple.create(entry.getKey(), entry.getValue());
                } else {
                    return null;
                }
            }
        }), (Tuple<K, V>) null);
    }
730624
function pick(obj) {
  var copy = {};
  var keys = Array.prototype.concat.apply(Array.prototype, Array.prototype.slice.call(arguments, 1));
  forEach(keys, function(key) {
    if (key in obj) copy[key] = obj[key];
  });
  return copy;
}
927410
function pickReverseEach( reverse, node, callback ) {
        var test = type.call( node, 'Undefined' ) ||
            node==='false' ||
            node===false ||
            (
                type.call( node, 'Boolean' ) && 
                !node.valueOf()
            );

        if ( test ) {
            pickReverse.call( this, reverse, true, callback );
        }
        else if ( type.call( node.isBoolean, 'Function' ) ) {
            if ( node.isBoolean.tick ) {

            }
            else {
                pickReverse.call( this, reverse, ( ( node.isBoolean() && !node.valueOf() ) || !node ), callback );
            }
        }
        else {
            pickReverse.call( this, reverse, !node, callback );
        }
    }
1105695
private AccessControlEntry pick( AccessControlList acl,
                                     String principal ) throws RepositoryException {
        for (AccessControlEntry entry : acl.getAccessControlEntries()) {
            if (entry.getPrincipal().getName().equals(principal)) {
                return entry;
            }
        }
        return null;
    }
1352362
public void handleSelection(String itemId) {

        Collection<?> selection = (Collection<?>)m_fileTable.getValue();
        if (selection == null) {
            m_fileTable.select(itemId);
        } else if (!selection.contains(itemId)) {
            m_fileTable.setValue(null);
            m_fileTable.select(itemId);
        }
    }
514386
function _select (node, expr) {
        var
            resultSet,
            nodeSet = [node];
        while (expr) {
            resultSet = [];
            _test(nodeSet, expr, resultSet);
            if (0 === resultSet.length) {
                return [];
            }
            nodeSet = resultSet;
            if (expr.filter) {
                resultSet = [];
                _each(nodeSet, _filter, expr.filter, resultSet);
                if (0 === resultSet.length) {
                    return [];
                }
                nodeSet = resultSet;
            }
            expr = expr.then;
        }
        return resultSet;
    }
658292
function pickResult(result, i) {
		try {
			return JSON.parse(result.body)
		}
		catch(e) {
			return Promise.reject({ index: i, reason: e })
		}
	}
21772
protected GVRPickedObject findCollider(GVRPickedObject[] pickList, GVRCollider findme)
    {
        if (pickList == null)
        {
            return null;
        }
        for (GVRPickedObject hit : pickList)
        {
            if ((hit != null) && (hit.hitCollider == findme))
            {
                return hit;
            }
        }
        return null;
    }
1020109
static SquareNode pickNot( SquareNode target , SquareNode child ) {
		for (int i = 0; i < 4; i++) {
			SquareEdge e = target.edges[i];
			if( e == null )
				continue;
			SquareNode c = e.destination(target);
			if( c != child )
				return c;
		}
		throw new RuntimeException("There was no odd one out some how");
	}
1059740
public static <T> T pick(T[] values) {
		if (values == null || values.length == 0)
			return null;

		return values[RandomInteger.nextInteger(values.length)];
	}
279297
protected void doPick()
    {
        GVRSceneObject owner = getOwnerObject();
        GVRTransform trans = (owner != null) ? owner.getTransform() : null;
        GVRPickedObject[] picked;

        if (mPickClosest)
        {
            GVRPickedObject closest = pickClosest(mScene, trans,
                mRayOrigin.x, mRayOrigin.y, mRayOrigin.z,
                mRayDirection.x, mRayDirection.y, mRayDirection.z);
            if (closest != null)
            {
                picked = new GVRPickedObject[] { closest };
            }
            else
            {
                picked = new GVRPickedObject[0];
            }
        }
        else
        {
            picked = pickObjects(mScene, trans,
                    mRayOrigin.x, mRayOrigin.y, mRayOrigin.z,
                    mRayDirection.x, mRayDirection.y, mRayDirection.z);
        }
        generatePickEvents(picked);
        mMotionEvent = null;
    }
730090
@Override
    protected void doPick()
    {
        if (mCollidables.size() > 0)
        {
            GVRPickedObject[] picked = null;

            synchronized (mCollidables)
            {
                picked = pickBounds(mScene, mCollidables);
            }
            if (mPickClosest && (picked.length > 0))
            {
                GVRPickedObject closest = null;
                float dist = 100000.0f;
                for (GVRPickedObject hit : picked)
                {
                    if ((hit != null) && (hit.hitDistance < dist))
                    {
                        dist = hit.hitDistance;
                        closest = hit;
                    }
                }
                if (closest != null)
                {
                    picked = new GVRPickedObject[] { closest };
                }
                else
                {
                    picked = sEmptyList;
                }
            }
            generatePickEvents(picked);
        }
    }
389453
function select(word) {	
		var input = this;
		var value = input.val();
		if (word) {
			input.val(
				value
				+ word.substr(value.split(/ |\n/).pop().length)
			);
			
			// Select hint.
			input[0].selectionStart = value.length;
		}
	}
1073106
static MeasuredNode pickBest(MeasuredNode a, MeasuredNode b) {
    if (a.length == b.length) {
      return (b.isChanged()) ? a : b;
    }

    return (a.length < b.length) ? a : b;
  }
896648
def pick(picklist,val):
    ''''''
    
    assert np.all(np.sort(picklist) == picklist), "pick list is not ordered correctly"
    val = np.array(val)
    i_pick, i_val = np.mgrid[0:len(picklist),0:len(val)]
    #
    # Mark a picklist entry as 1 if the value is before or at,
    # mark it as zero if it is afterward
    #
    is_not_larger = picklist[i_pick] <= val[i_val]
    #
    # The index is the number of entries that are 1
    #
    p = np.sum(is_not_larger, 0)
    
    return p
19090
def pick(self, selector, entity_set, min_quantity=None):
        
        if isinstance(selector, int):
            for e in entity_set:
                if e.id == selector:
                    return set((e,))
        else:
            if selector.lower() in ('self', 'me', 'myself'):
                return set((self.entity,))

            return set(
                e for e in entity_set
                if (e.is_('Named') and selector.lower() in e.Named.name.lower())
                and not e.is_(Invisible)
                and (not min_quantity or min_quantity == 1 or (e.is_(Stackable) and e.Stackable.quantity >= min_quantity))
            )
1128270
private static Response pick(final Request req,
        final Iterable<Fork> forks) throws IOException {
        for (final Fork fork : forks) {
            final Opt<Response> rsps = fork.route(req);
            if (rsps.has()) {
                return rsps.get();
            }
        }
        throw new HttpException(HttpURLConnection.HTTP_NOT_FOUND);
    }