Checks if this rectangle contains a given point.<p>

@param point the point to check

@return true if the point is contained in the rectangle
778807
public boolean contains(CmsPoint point) {

        return (point.getX() >= m_left)
            && (point.getX() < (m_left + m_width))
            && (point.getY() >= m_top)
            && (point.getY() < (m_top + m_height));
    }
1209834
public boolean typeAndThresholdContainsDetectionPoint(DetectionPoint detectionPoint) {
		for (DetectionPoint myPoint : getAllDetectionPoints()) {
			if (detectionPoint.typeAndThresholdMatches(myPoint)) {
				return true;
			}
		}
		return false;
	}
1084507
public boolean containsPoint2D(double[] v) {
    assert (v.length == 2);
    final double testx = v[0];
    final double testy = v[1];
    boolean c = false;

    Iterator<double[]> it = points.iterator();
    double[] pre = points.get(points.size() - 1);
    while(it.hasNext()) {
      final double[] cur = it.next();
      final double curx = cur[0], cury = cur[1];
      final double prex = pre[0], prey = pre[1];
      if(((cury > testy) != (prey > testy))) {
        if((testx < (prex - curx) * (testy - cury) / (prey - cury) + curx)) {
          c = !c;
        }
      }
      pre = cur;
    }
    return c;
  }
180495
@Pure
	public boolean containsProjectionOf(Point3f point) {
		return containsProjectionOf(point.getX(), point.getY(), point.getZ());
	}
1123550
public boolean contains(Vector3f point) {
        return contains(point.getX(), point.getY(), point.getZ());
    }
98836
func (r Rect) ContainsPoint(p Point) bool {
	return r.X.Contains(p.X) && r.Y.Contains(p.Y)
}
275579
public boolean contains(String name)
    {
        Part part = (Part)_partMap.get(name);
        return (part!=null);
    }
611473
function(point) {
        var result = false;

        if (point) {
            result =
                this.x === point.x &&
                this.y === point.y;
        }

        return result;
    }
1353765
@Override
    public boolean contains(int c) {
        if (c < MIN_VALUE || c > MAX_VALUE) {
            throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(c, 6));
        }
        if (bmpSet != null) {
            return bmpSet.contains(c);
        }
        if (stringSpan != null) {
            return stringSpan.contains(c);
        }

        /*
        // Set i to the index of the start item greater than ch
        // We know we will terminate without length test!
        int i = -1;
        while (true) {
            if (c < list[++i]) break;
        }
         */

        int i = findCodePoint(c);

        return ((i & 1) != 0); // return true if odd
    }
844959
public boolean contains(Color color) {
        return exists(p -> p.toInt() == color.toPixel().toInt());
    }
1069695
@Pure
	public boolean containsPoint(Point2D<?, ?> point, int groupIndex) {
		final int grpCount = getGroupCount();
		if (groupIndex < 0) {
			throw new IndexOutOfBoundsException(groupIndex + "<0"); //$NON-NLS-1$
		}
		if (groupIndex > grpCount) {
			throw new IndexOutOfBoundsException(groupIndex + ">" + grpCount); //$NON-NLS-1$
		}
		if (point == null) {
			return false;
		}

		for (int i = 0; i < getPointCountInGroup(groupIndex); ++i) {
			final Point2d cur = getPointAt(groupIndex, i);
			if (cur.epsilonEquals(point, MapElementConstants.POINT_FUSION_DISTANCE)) {
				return true;
			}
		}
		return false;
	}
1036549
public static boolean isPointInBoundingBox(Point point,
			BoundingBox boundingBox) {
		BoundingBox pointBoundingbox = new BoundingBox(point.getX(),
				point.getY(), point.getX(), point.getY());
		return boundingBox.intersects(pointBoundingbox, true);
	}
1045544
public boolean contains(T object) {
        synchronized (mLock) {
            if (mOriginalValues != null) {
                return mOriginalValues.contains(object);
            } else {
                return mObjects.contains(object);
            }
        }
    }
744737
function isVisiblePoint(point) {
  if (isText(point.node) || !hasChildren(point.node) || isEmpty(point.node)) {
    return true;
  }

  const leftNode = point.node.childNodes[point.offset - 1];
  const rightNode = point.node.childNodes[point.offset];
  if ((!leftNode || isVoid(leftNode)) && (!rightNode || isVoid(rightNode))) {
    return true;
  }

  return false;
}
888154
public boolean contains(String name) {
        if (name == null) {
            throw new IllegalArgumentException("Other cannot be null");
        }

        if (this.name.equals(name)) {
            return true;
        }

        if (hasReferences()) {
            for (Marker ref : referenceList) {
                if (ref.contains(name)) {
                    return true;
                }
            }
        }
        return false;
    }
219292
def contains(self, point):
    
    return (
          point[0] >= self.minpt[0] 
      and point[1] >= self.minpt[1]
      and point[2] >= self.minpt[2] 
      and point[0] <= self.maxpt[0] 
      and point[1] <= self.maxpt[1]
      and point[2] <= self.maxpt[2]
    )
1039438
public static CellPosition of(final Point point) {
        ArgUtils.notNull(point, "point");
        return of(point.y, point.x);
    }