Replies the isPolygon property.

@return the isPolygon property.
176581
public BooleanProperty isPolygonProperty() {
		if (this.isPolygon == null) {
			this.isPolygon = new ReadOnlyBooleanWrapper(this, MathFXAttributeNames.IS_POLYGON, false);
			this.isPolygon.bind(Bindings.createBooleanBinding(() -> {
				boolean first = true;
				boolean lastIsClose = false;
				for (final PathElementType type : innerTypesProperty()) {
					lastIsClose = false;
					if (first) {
						if (type != PathElementType.MOVE_TO) {
							return false;
						}
						first = false;
					} else if (type == PathElementType.MOVE_TO) {
						return false;
					} else if (type == PathElementType.CLOSE) {
						lastIsClose = true;
					}
				}
				return lastIsClose;
			},
					innerTypesProperty()));
		}
		return this.isPolygon;
	}
506026
public boolean isLocal()
    {
        return CIAdminUser.RoleLocal.getType() == null ? false
                        : CIAdminUser.RoleLocal.getType().getId() == this.typeId;
    }
223056
public boolean isMap() {
        if (type instanceof Message) {
            Message message = (Message) type;
            return message.isMapEntry();
        }
        return false;
    }
913290
public JTSGeometryExpression<Geometry> boundary() {
        if (boundary == null) {
            boundary = JTSGeometryExpressions.geometryOperation(SpatialOps.BOUNDARY, mixin);
        }
        return boundary;
    }
378443
public boolean isInnerNode()
  {
    boolean inner = true;
    if ( (_leftChild  == null) ||
         (_rightChild == null) )
      inner = false;
    return inner;
  }
152865
@Pure
	public DoubleProperty radiusProperty() {
		if (this.radius == null) {
			this.radius = new SimpleDoubleProperty(this, MathFXAttributeNames.RADIUS) {
				@Override
				protected void invalidated() {
					if (get() < 0.) {
						set(0.);
					}
				}
			};
		}
		return this.radius;
	}
687864
public Polygon getHull() {
    if(!ok) {
      computeConvexHull();
    }
    return new Polygon(points, minmaxX.getMin(), minmaxX.getMax(), minmaxY.getMin(), minmaxY.getMax());
  }
996353
public boolean isForeign()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.entry(tc, "isForeign");
    
    boolean isForeign = aliasDest.isForeign();
    
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) 
      SibTr.exit(tc, "isForeign", new Boolean(isForeign));
    
    return isForeign;
  }
1034566
public static boolean isNearMultipleBorders(@Nonnull final Point point, @Nonnull final Territory territory) {
        checkDefined("point", point);
        if (territory != Territory.AAA) {
            final int territoryNumber = territory.getNumber();
            if (territory.getParentTerritory() != null) {
                // There is a parent! check its borders as well...
                if (isNearMultipleBorders(point, territory.getParentTerritory())) {
                    return true;
                }
            }
            int nrFound = 0;
            final int fromTerritoryRecord = DATA_MODEL.getDataFirstRecord(territoryNumber);
            final int uptoTerritoryRecord = DATA_MODEL.getDataLastRecord(territoryNumber);
            for (int territoryRecord = uptoTerritoryRecord; territoryRecord >= fromTerritoryRecord; territoryRecord--) {
                if (!Data.isRestricted(territoryRecord)) {
                    final Boundary boundary = Boundary.createBoundaryForTerritoryRecord(territoryRecord);
                    final int xdiv8 = Common.xDivider(boundary.getLatMicroDegMin(), boundary.getLatMicroDegMax()) / 4;
                    if (boundary.extendBoundary(60, xdiv8).containsPoint(point)) {
                        if (!boundary.extendBoundary(-60, -xdiv8).containsPoint(point)) {
                            nrFound++;
                            if (nrFound > 1) {
                                return true;
                            }
                        }
                    }
                }
            }
        }
        return false;
    }
482003
public static boolean isPropertyType(final Type type) {
        if (type instanceof GenericArrayType) {
            return isPropertyType(((GenericArrayType) type).getGenericComponentType());
        }
        if (type instanceof ParameterizedType) {
            return isPropertyType(((ParameterizedType) type).getRawType());
        }
        return type instanceof Class && isPropertyType((Class) type);
    }
1175548
@XmlElementDecl(namespace = "http://www.opengis.net/gml", name = "polygonMember")
    public JAXBElement<PolygonPropertyType> createPolygonMember(PolygonPropertyType value) {
        return new JAXBElement<PolygonPropertyType>(_PolygonMember_QNAME, PolygonPropertyType.class, null, value);
    }
429938
@RestrictTo(LIBRARY_GROUP)
    public boolean isRoundRect() {
        boolean hasDefaultEdges =
                leftEdge.getClass().equals(EdgeTreatment.class)
                        && rightEdge.getClass().equals(EdgeTreatment.class)
                        && topEdge.getClass().equals(EdgeTreatment.class)
                        && bottomEdge.getClass().equals(EdgeTreatment.class);

        float cornerSize = topLeftCorner.getCornerSize();

        boolean cornersHaveSameSize =
                topRightCorner.getCornerSize() == cornerSize
                        && bottomLeftCorner.getCornerSize() == cornerSize
                        && bottomRightCorner.getCornerSize() == cornerSize;

        boolean hasRoundedCorners =
                topRightCorner instanceof RoundedCornerTreatment
                        && topLeftCorner instanceof RoundedCornerTreatment
                        && bottomRightCorner instanceof RoundedCornerTreatment
                        && bottomLeftCorner instanceof RoundedCornerTreatment;

        return hasDefaultEdges && cornersHaveSameSize && hasRoundedCorners;
    }
620659
public boolean isValid() {
		if (!isEmpty()) {
			for (int i = 0; i < polygons.length; i++) {
				if (!polygons[i].isValid()) {
					return false;
				}
				for (int j = i + 1; j < polygons.length; j++) {
					if (polygons[i].intersects(polygons[j])) {
						return false;
					}
				}
			}
		}
		return true;
	}
1229392
public function hasLoop()
    {
        foreach ($this->set->getEdges() as $edge) {
            if ($edge->isLoop()) {
                return true;
            }
        }

        return false;
    }
1110298
@Pure
	boolean containsControlPoint(Point3D p) {
		double x, y, z;
		for(int i=0; i<this.numCoordsProperty.get();) {
			x = this.coordsProperty[i++].get();
			y = this.coordsProperty[i++].get();
			z = this.coordsProperty[i++].get();
			if (x==p.getX() && y==p.getY() && z==p.getZ()) {
				return true;
			}
		}
		return false;
	}
1157116
public static boolean isPointOnPolygon(LatLng point, PolygonOptions polygon, boolean geodesic, double tolerance) {

        boolean onPolygon = PolyUtil.containsLocation(point, polygon.getPoints(), geodesic) ||
                PolyUtil.isLocationOnEdge(point, polygon.getPoints(), geodesic, tolerance);

        if (onPolygon) {
            for (List<LatLng> hole : polygon.getHoles()) {
                if (PolyUtil.containsLocation(point, hole, geodesic)) {
                    onPolygon = false;
                    break;
                }
            }
        }

        return onPolygon;
    }
712073
@Override
    public boolean isSingular() {
        for( int i = 0; i < m; i++ ) {
            if( Math.abs(dataLU[i* n +i]) < UtilEjml.EPS )
                return true;
        }
        return false;
    }