// Contains checks whether a vector u is contained within this Rect (including it's borders).
346954
func (r Rect) Contains(u Vec) bool {
	return r.Min.X <= u.X && u.X <= r.Max.X && r.Min.Y <= u.Y && u.Y <= r.Max.Y
}
471094
func (s VarSet) Contains(v Var) bool {
	_, ok := s[v]
	return ok
}
40571
func (e EdgeSet) Contains(v, w int) bool {
	switch {
	case e.Keep != nil && !e.Keep(v, w):
		return false
	case e.From.Contains(v) && e.To.Contains(w):
		return true
	case e.To.Contains(v) && e.From.Contains(w):
		return true
	default:
		return false
	}
}
1028343
func Contains(x interface{}) Matcher {
	var result containsMatcher
	var ok bool

	if result.elementMatcher, ok = x.(Matcher); !ok {
		result.elementMatcher = Equals(x)
	}

	return &result
}
713393
func (r Rect) Contains(other Rect) bool {
	return r.Lat.ContainsInterval(other.Lat) && r.Lng.ContainsInterval(other.Lng)
}
160179
func (term Range) Contains(other Range) bool {
	return term.Intersection(other).Equals(other)
}
849261
func (f *Filter) Contains(v []byte) bool {
	h := f.hash(v)
	for i := uint64(0); i < f.k; i++ {
		loc := f.location(h, i)
		if f.b[loc>>3]&(1<<(loc&7)) == 0 {
			return false
		}
	}
	return true
}
1323076
func contains(slice []string, entry string) bool {
	for _, element := range slice {
		if element == entry {
			return true
		}
	}
	return false
}
993826
func (m *MultiMap) Contains(key interface{}, value interface{}) bool {
	set, found := m.m[key]
	if _, ok := set[value]; ok {
		return true && found
	}
	return false && found
}
313004
func (p *Polygon) Contains(point *Point) bool {
	if !p.IsClosed() {
		return false
	}

	start := len(p.points) - 1
	end := 0

	contains := p.intersectsWithRaycast(point, p.points[start], p.points[end])

	for i := 1; i < len(p.points); i++ {
		if p.intersectsWithRaycast(point, p.points[i-1], p.points[i]) {
			contains = !contains
		}
	}

	return contains
}
1074672
func (actionSet ActionSet) Contains(action Action) bool {
	_, found := actionSet[action]
	return found
}
634817
func (ls LabelArray) Contains(needed LabelArray) bool {
nextLabel:
	for i := range needed {
		for l := range ls {
			if needed[i].Matches(&ls[l]) {
				continue nextLabel
			}
		}

		return false
	}

	return true
}
98836
func (r Rect) ContainsPoint(p Point) bool {
	return r.X.Contains(p.X) && r.Y.Contains(p.Y)
}
807392
func (e Entries) Contains(entry *Entry) bool {
	for _, curr := range e {
		if curr.Equals(entry) {
			return true
		}
	}
	return false
}
1048563
func (f *FST) Contains(val []byte) (bool, error) {
	_, exists, err := f.Get(val)
	return exists, err
}
368931
func (b *BinaryTree) Contains(target Comparable) bool {
	return b.search(target) != nil
}
933297
func (it *And) Contains(ctx context.Context, val graph.Value) bool {
	graph.ContainsLogIn(it, val)
	it.runstats.Contains += 1
	lastResult := it.result
	if it.checkList != nil {
		return it.checkContainsList(ctx, val, lastResult)
	}
	mainGood := it.primaryIt.Contains(ctx, val)
	if mainGood {
		othersGood := it.subItsContain(ctx, val, lastResult)
		if othersGood {
			it.result = val
			return graph.ContainsLogOut(it, val, true)
		}
	}
	if lastResult != nil {
		it.primaryIt.Contains(ctx, lastResult)
	}
	return graph.ContainsLogOut(it, val, false)
}