Returns True if the envelope contains the point (boundary exclusive).
@param x
@param y
@return True if this contains the point.
553279
public boolean containsExclusive(double x, double y) {
		// Note: This will return False, if envelope is empty, thus no need to
		// call is_empty().
		return x > xmin && x < xmax && y > ymin && y < ymax;
	}
372811
public boolean contains(Shape other) {
    	if (other.intersects(this)) {
    		return false;
    	}
    	
    	for (int i=0;i<other.getPointCount();i++) {
    		float[] pt = other.getPoint(i);
    		if (!contains(pt[0], pt[1])) {
    			return false;
    		}
    	}
    	
    	return true;
    }
29534
def containsbb_exclusive(self, x):
        
        left, bottom, right, top = self.aarect().lbrt()
        leftx, bottomx, rightx, topx = x.aarect().lbrt()
        return (left <= leftx) and (bottom <= bottomx) and (right >= rightx) and (top >= topx) and\
               (not ((left == leftx) and (bottom == bottomx) and (right == rightx) and (top == topx)))
606600
private static boolean pointTouchesEnvelope_(Point2D pt_a,
			Envelope2D env_b, double tolerance, ProgressTracker progress_tracker) {
		if (env_b.getHeight() <= tolerance && env_b.getWidth() <= tolerance)
			return false; // when treates as a point, points cannot touch points

		Envelope2D env_b_inflated = new Envelope2D(), env_b_deflated = new Envelope2D();

		env_b_inflated.setCoords(env_b);
		env_b_inflated.inflate(tolerance, tolerance);

		if (!env_b_inflated.contains(pt_a))
			return false;

		if (env_b.getHeight() <= tolerance || env_b.getWidth() <= tolerance) {
			env_b_deflated.setCoords(env_b);

			if (env_b.getHeight() > tolerance)
				env_b_deflated.inflate(0, -tolerance);
			else
				env_b_deflated.inflate(-tolerance, 0);

			if (env_b.getHeight() > tolerance) {
				if (pt_a.y > env_b_deflated.ymin
						&& pt_a.y < env_b_deflated.ymax)
					return false;
			} else {
				if (pt_a.x > env_b_deflated.xmin
						&& pt_a.x < env_b_deflated.xmax)
					return false;
			}

			return true;
		}

		env_b_deflated.setCoords(env_b);
		env_b_deflated.inflate(-tolerance, -tolerance);

		if (env_b_deflated.containsExclusive(pt_a))
			return false;

		return true;
	}
614221
private static boolean multiPointContainsMultiPoint_(
			MultiPoint multipoint_a, MultiPoint multipoint_b, double tolerance,
			ProgressTracker progress_tracker) {
		Envelope2D env_a = new Envelope2D(), env_b = new Envelope2D();
		multipoint_a.queryEnvelope2D(env_a);
		multipoint_b.queryEnvelope2D(env_b);

		if (!envelopeInfContainsEnvelope_(env_a, env_b, tolerance))
			return false;

		return multiPointCoverageMultiPoint_(multipoint_b, multipoint_a,
				tolerance, true, false, false, progress_tracker);
	}
675786
@Pure
	public boolean containsProjectionOf(double x, double y, double z) {
		Point3f proj = (Point3f) getPlane().getProjection(x, y, z);
		if (proj == null) {
			return false;
		}
		return contains(proj);
	}
495960
public void addPoint(double x, double y)
    {
        if (npoints >= xpoints.length)
        {
            final int newLength = npoints * 2;
            xpoints = Arrays.copyOf(xpoints, newLength);
            ypoints = Arrays.copyOf(ypoints, newLength);
        }
        xpoints[npoints] = x;
        ypoints[npoints] = y;
        npoints++;
        updateBounds();
    }
845649
function isPointOverlap(p0, p1) {
            return ceil(p0.x) === ceil(p1.x) && ceil(p0.y) === ceil(p1.y);
        }
109537
def contains_point?(pt)
      pt.x.between?(left, left + width - 1) &&
        pt.y.between?(top, top + height - 1)
    end
1198099
public boolean contains(E p)
  {
    // Check that the start point is before p
    boolean check1 = (includesBegin())? (first.compareTo(p) <= 0):(first.compareTo(p) < 0);
    // Check that the end point is after p
    boolean check2 = (includesEnd())? (second.compareTo(p) >= 0):(second.compareTo(p) > 0);
    return (check1 && check2);
  }
844187
@Override
  public boolean contains(final int x) {
    final short hb = highbits(x);
    int index = highLowContainer.getContainerIndex(hb);
    return index >= 0
        && highLowContainer.containsForContainerAtIndex(index, lowbits(x));
  }
681818
public boolean isExcluded(String endpoint) {
        for (int i = 0; i < exclusions.size(); i++) {
            if (exclusions.get(i).test(endpoint)) {
                return true;
            }
        }
        return false;
    }
1346930
public boolean isIntersecting(Envelope2D other) {
		// No need to check if empty, this will work for empty envelopes too
		// (IEEE math)
		return ((xmin <= other.xmin) ? xmax >= other.xmin : other.xmax >= xmin)
				&& // check that x projections overlap
				((ymin <= other.ymin) ? ymax >= other.ymin : other.ymax >= ymin); // check
																					// that
																					// y
																					// projections
																					// overlap
	}
687014
public static boolean equals2(Object x, Object y) {
        if (x instanceof java.lang.Number)
            return equalsNumObject((java.lang.Number)x, y);
        if (x instanceof java.lang.Character)
            return equalsCharObject((java.lang.Character)x, y);
        if (x == null)
            return y == null;

        return x.equals(y);
    }
1308697
public static boolean equalsObjects(
      @javax.annotation.Nullable Object x, @javax.annotation.Nullable Object y) {
    return x == null ? y == null : x.equals(y);
  }
668646
static private boolean isAncestorPath(String x, String y) {
    if (!y.startsWith(x)) {
      return false;
    }
    final int len = x.length();
    return y.length() == len || y.charAt(len) == Path.SEPARATOR_CHAR;  
  }
131114
public boolean isInsideBounds(int x, int y)
	{
		if (!isVisible())
			return false;
		int sx = screenPosition().x();
		int sy = screenPosition().y();
		return x >= sx && x <= sx + size().width() && y >= sy && y <= sy + size().height();
	}