Determines if the current interval is a single point.

@return {@code true}, if the current interval represents a single point.
355576
public boolean isPoint(){
		if (start == null || end == null) {
			return false;
		}
		return start.compareTo(end) == 0 && isStartInclusive && isEndInclusive;
	}
292474
public boolean isOver() {
        if (!isOver) {
            final long now = System.currentTimeMillis();
            isOver = now - startTime >= duration;
        }
        return isOver;
    }
165588
private static boolean pointEqualsPoint_(Point2D pt_a, Point2D pt_b,
			double tolerance, ProgressTracker progress_tracker) {
		if (Point2D.sqrDistance(pt_a, pt_b) <= tolerance * tolerance)
			return true;

		return false;
	}
178392
final public boolean isSingleServer() {
        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled())
            SibTr.entry(tc, "isSingleServer");
        if (!_singleServerSet) {
            JsAdminService service = JsMainAdminComponentImpl.getJsAdminService();
            if (service.isInitialized())
                _isSingleServer = service.isStandaloneServer();
            else
                // If admin service isn't initialised, then assume we are single
                // service.
                _isSingleServer = true;

            _singleServerSet = true;
        }

        if (TraceComponent.isAnyTracingEnabled()
            && tc.isEntryEnabled())
            SibTr.exit(tc, "isSingleServer", new Boolean(_isSingleServer));
        return _isSingleServer;
    }
330223
synchronized boolean removeInterval(Interval i) {
        calcMinDuration = null;
        calcMaxDuration = null;
        calcMinFinish = null;
        calcMaxFinish = null;
        calcMinStart = null;
        calcMaxStart = null;
        shortestDistancesFromTimeZeroSource = null;
        shortestDistancesFromTimeZeroDestination = null;

        if (directedGraph.remove(i.getStart()) != null) {
            if (directedGraph.remove(i.getFinish()) == null) {
                throw new IllegalStateException();
            }
            intervals.remove(i);
            return true;
        } else {
            return false;
        }
    }
59696
boolean hasValidTimes() {

        if ((getEnd() > 0L) && (getEnd() < System.currentTimeMillis())) {
            return false;
        }

        return ((getEnd() == 0) | (getStart() == 0)) || (getEnd() >= getStart());
    }
308566
function () {
        var point = 1;
        breakpoints.forEach(function (bp) {
            if (global.innerWidth >= bp) {
                point = bp;
            }
        });
        return breakpoints.length ? point : void(0);
    }
1148889
public boolean isRangeSet() {
		for (int i = 0; i < getDimensions(); i++) {
			if( valueMin[i] == 0 && valueMax[i] == 0 ) {
				return false;
			}
		}

		return true;
	}
244489
public boolean isValid() {
		if (isEmpty()) {
			return true;
		}
		if (!isClosed()) {
			return false;
		}
		Coordinate[] coordinates = getCoordinates();

		if (coordinates.length < 4) {
			return false;
		}

		for (int i = 0; i < coordinates.length - 1; i++) {
			for (int j = 0; j < coordinates.length - 1; j++) {
				if (Mathlib.lineIntersects(coordinates[i], coordinates[i + 1], coordinates[j], coordinates[j + 1])) {
					return false;
				}
			}
		}

		return true;
	}
555914
@Pure
	public boolean contains(FunctionalPoint3D point) {
		return containsTrianglePoint(
				this.getP1().getX(), this.getP1().getY(), this.getP1().getZ(), 
				this.getP2().getX(), this.getP2().getY(), this.getP2().getZ(), 
				this.getP3().getX(), this.getP3().getY(), this.getP3().getZ(),
				point.getX(), point.getY(), point.getZ(),
				true, 0.);
	}
618671
public boolean isSingle() {
    // assume simplified
    if ((positiveQueryList.size() == 1) && (negativeQueryList.size() == 0)) {
      return true;
    } else if ((positiveQueryList.size() == 0)
        && (negativeQueryList.size() == 1)) {
      return true;
    }
    return false;
  }
545931
public boolean before(final Interval<C> that) {
        if(this.hasNone() || that.hasNone()) {
            return false;
        }
        return this.dimension == that.dimension &&
               this.range.upperEndpoint().compareTo(that.range.lowerEndpoint()) < 0;
    }
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);
	}
778991
boolean hasPointFeatures()
    {
      for (int geometry = getFirstGeometry(); geometry != -1; geometry = getNextGeometry(geometry))
      {
        if (!Geometry.isMultiPath(getGeometryType(geometry)))
          return true;
      }
      return false;
    }
180495
@Pure
	public boolean containsProjectionOf(Point3f point) {
		return containsProjectionOf(point.getX(), point.getY(), point.getZ());
	}
333384
static boolean heartbeatHasBeenSkipped(EventChannelStruct eventChannelStruct) {
        long now = System.currentTimeMillis();
        //System.out.println(now + "-" + eventChannelStruct.last_heartbeat + "=" +
        //        (now - eventChannelStruct.last_heartbeat));
        return ((now - eventChannelStruct.last_heartbeat) > EVENT_HEARTBEAT_PERIOD);
    }
750061
public boolean isSimple() {
		if (isEmpty()) {
			return true;
		}

		if (getNumGeometries() > 1) {
			for (int n = 0; n < getNumGeometries(); n++) {
				if (!getGeometryN(n).isSimple()) {
					return false;
				}
			}
		} else {
			final Coordinate[] coords1 = getCoordinates();
			final Coordinate[] coords2 = getCoordinates();
			if (coords1.length > 1 && coords2.length > 1) {
				for (int i = 0; i < coords2.length - 1; i++) {
					for (int j = 0; j < coords1.length - 1; j++) {
						if (Mathlib.lineIntersects(coords2[i], coords2[i + 1], coords1[j], coords1[j + 1])) {
							return false;
						}
					}
				}
			} else {
				// TODO implement me
			}
		}

		return true;
	}