Determines if this IRI is absolute

@return {@code true} if this IRI is absolute or {@code false} if this IRI
is not absolute
171677
public boolean isAbsolute() {
        int colonIndex = namespace.indexOf(':');
        if (colonIndex == -1) {
            return false;
        }
        for (int i = 0; i < colonIndex; i++) {
            char ch = namespace.charAt(i);
            if (!Character.isLetter(ch) && !Character.isDigit(ch) && ch != '.' && ch != '+' && ch != '-') {
                return false;
            }
        }
        return true;
    }
958780
public boolean isInverse() {
		Boolean value = (Boolean) getStateHelper().eval(PropertyKeys.inverse, false);
		return (boolean) value;
	}
1370014
public boolean getBoolean() throws IOException {
        if (tag != tag_Boolean) {
            throw new IOException("DerValue.getBoolean, not a BOOLEAN " + tag);
        }
        if (length != 1) {
            throw new IOException("DerValue.getBoolean, invalid length "
                                        + length);
        }
        if (buffer.read() != 0) {
            return true;
        }
        return false;
    }
713401
private boolean isBinary() {
        try (InputStream in = getInputStream()) {
            long size = Files.size(file.toPath());
            if (size == 0) {
                // Empty file, so no need to check
                return true;
            }

            byte[] b = new byte[( size < StreamUtils.DEFAULT_PROBE_SIZE ? (int)size : StreamUtils.DEFAULT_PROBE_SIZE)];
            int read = in.read(b);
            if (read != b.length) {
                // Something went wrong, so better not to read line by line
                return true;
            }

            return StreamUtils.isNonWhitespaceControlCharacter(b);
        } catch (IOException e) {
            // If cannot be checked, then considered as binary, so we do not
            // read line by line
            return true;
        }
    }
753017
public boolean isNonsingular () {
		for (int j = 0; j < n; j++) {
			if (LU[j][j] == 0)
				return false;
		}
		return true;
	}
903801
public boolean isThumbnail() {
    if (tags.containsTagId(254)) {
      if (tags.get(254).getCardinality() > 0)
        return BigInteger.valueOf(tags.get(254).getFirstNumericValue()).testBit(0);
    }
    if (tags.containsTagId(255)) {
      if (tags.get(255).getCardinality() > 0)
        return tags.get(255).getFirstNumericValue() == 2;
    }
    if (hasSubIFD() && getImageSize() < getsubIFD().getImageSize()) {
      return true;
    }
    if (hasParent() && getImageSize() < getParent().getImageSize()) {
      return true;
    }
    return false;
  }
474738
public static boolean isAllOneColor( BufferedImage image ) {
        int width = image.getWidth();
        int height = image.getHeight();
        int previousRgb = 0;
        boolean isFirst = true;
        for( int x = 0; x < width; x++ ) {
            for( int y = 0; y < height; y++ ) {
                int rgb = image.getRGB(x, y);
                if (isFirst) {
                    isFirst = false;
                } else {
                    if (rgb != previousRgb) {
                        return false;
                    }
                }
                previousRgb = rgb;
            }
        }
        return true;
    }
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;
    }
635193
@Override
    public int isCompatible(Class<?> target, Object actual) {
        int superCompat = super.isCompatible(target, actual);
        if (superCompat >= 0 && superCompat < 3) {
            return superCompat;
        }

        Class<?> actualClass = actual.getClass();
        if (actualClass == Types.UNDEFINED.getClass() || actualClass == Types.NULL.getClass()) {
            return 3;
        }

        if (JSFunction.class.isAssignableFrom(actualClass)) {
            if (isSingleAbstractMethod(target) != null) {
                return 3;
            }
        }

        return -1;
    }
354273
@Override
    public boolean asBoolean() {
        final Class<?> callerClass = ReflectionHelper.getDirectCallerClass();
        return evaluateSingeValue(Boolean.TYPE, callerClass);
    }
948037
public static final boolean isArchive(InputStream in) throws IOException {
        if (in != null) {
            try (ZipInputStream zip = new ZipInputStream(in)){
                return zip.getNextEntry() != null;
            } catch (ZipException e) {
                return false;
            }
        }
        return false;
    }
264288
private boolean absoluteBasic(int row)
    {
        boolean retval = false;
        
        if (row > m_current_row)
        {
            try
            {
                while (m_current_row < row && getRsAndStmt().m_rs.next())
                {
                    m_current_row++;
                }
                if (m_current_row == row)
                {
                    retval = true;
                }
                else
                {
                    setHasCalledCheck(true);
                    setHasNext(false);
                    retval = false;
                    autoReleaseDbResources();
                }
            }
            catch (Exception ex)
            {
                setHasCalledCheck(true);
                setHasNext(false);
                retval = false;
            }
        }
        else
        {
            logger.info("Your driver does not support advanced JDBC Functionality, " +
                    "you cannot call absolute() with a position < current");
        }
        return retval;
    }
1194082
public boolean isMatch() {
        if (shuntsuList.size() > 0) {
            return false;
        }
        for (Toitsu toitsu : toitsuList) {
            int num = toitsu.getTile().getNumber();
            if (1 < num && num < 9) {
                return false;
            }
        }

        for (Kotsu kotsu : kotsuList) {
            int num = kotsu.getTile().getNumber();
            if (1 < num && num < 9) {
                return false;
            }
        }
        return true;
    }
378443
public boolean isInnerNode()
  {
    boolean inner = true;
    if ( (_leftChild  == null) ||
         (_rightChild == null) )
      inner = false;
    return inner;
  }
608988
protected int absolutePosition()
  {
    if (tc.isEntryEnabled()) Tr.entry(tc, "absolutePosition", this);
    if (tc.isEntryEnabled()) Tr.exit(tc, "absolutePosition", new Integer(_absolutePosition));
    return _absolutePosition;
  }
1117861
public boolean isCorrect() {

        for (int n = 0; n < size; n++) {
            INDArray point = data.slice(index[n]);
            if (!boundary.containsPoint(point))
                return false;
        }

        return isLeaf() || northWest.isCorrect() && northEast.isCorrect() && southWest.isCorrect()
                        && southEast.isCorrect();

    }
1016340
public boolean isUnary() {
		Variable oneVar = this.scope[0];
		for (int i = 1; i < this.scope.length; i++) {
			if (!this.scope[i].equals(oneVar)) return false;
		}
		return true;
	}