Finds out if n represents an Integer.

@return true if n is instanceOf Integer or the literal value can be
evaluated as an Integer.
514780
private static boolean isInteger( Number n ) {
      if( n instanceof Integer ){
         return true;
      }
      try{
         Integer.parseInt( String.valueOf( n ) );
         return true;
      }catch( NumberFormatException e ){
         return false;
      }
   }
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;
  }
90680
def is_int(value):
    """"""
    if isinstance(value, bool):
        return False
    try:
        int(value)
        return True
    except (ValueError, TypeError):
        return False
1206974
public boolean isValueKnown() {
        Type type = getType();
        if (type != null) {
            Class<?> clazz = type.getObjectClass();
            return Number.class.isAssignableFrom(clazz) ||
                clazz.isAssignableFrom(Number.class);
        }
        else {
            return false;
        }
    }
704835
function isInteger(value) {
        // Validate value is a number
        if (typeof (value) !== "number" || isNaN(parseInt(value, 10))) {
            return false;
        }

        // Validate number is an integer
        if (Math.floor(value) !== value) {
            return false;
        }

        // Validate number is finite
        if (!isFinite(value)) {
            return false;
        }

        return true;
    }
1257338
function (n) {
            return n.every(function (a, i, args) {
                if (a === args[0]) {
                    return true;
                } else if (typeof a === 'number' && typeof args[0] === 'number') {
                    return Math.abs(a - args[0]) <= 3e-15;
                } else if (typeof a === 'object') {
                    return a.isEqual(args[0]);
                } else if (typeof args[0] === 'object') {
                    return args[0].isEqual(a);
                }
                return false;
            });
        }
844488
public static boolean isInteger(String number) {
        boolean result = false;
        try {
            Integer.parseInt(number);
            result = true;
        } catch (NumberFormatException e) {
        }
        return result;
    }
275212
boolean isNormal() {
        if (intLen + offset > value.length)
            return false;
        if (intLen == 0)
            return true;
        return (value[offset] != 0);
    }
675982
private static boolean isBigDecimal( Number n ) {
      if( n instanceof BigDecimal ){
         return true;
      }
      try{
         new BigDecimal( String.valueOf( n ) );
         return true;
      }catch( NumberFormatException e ){
         return false;
      }
   }
280353
private static boolean isDouble( Number n ) {
      if( n instanceof Double ){
         return true;
      }
      try{
         double d = Double.parseDouble( String.valueOf( n ) );
         return !Double.isInfinite( d );
      }catch( NumberFormatException e ){
         return false;
      }
   }
753017
public boolean isNonsingular () {
		for (int j = 0; j < n; j++) {
			if (LU[j][j] == 0)
				return false;
		}
		return true;
	}
720103
public boolean isNumber() {
        return ( this.simpleType == SimpleValueType.INTEGER ||
                 this.simpleType == SimpleValueType.DECIMAL ||
                 this.simpleType == SimpleValueType.CHAR || 
                 this.simpleType == SimpleValueType.NUMBER ) ;
    }
761759
public boolean isNumeric() {
		final Class c = getColumnClass();
		return c.equals(Integer.class) || c.equals(Float.class) || c.equals(Long.class) || c.equals(BigDecimal.class);
	}
300440
public static boolean isInteger(String s) {
        if (isEmpty(s)) return defaultEmptyOK;

        // Search through string's characters one by one
        // until we find a non-numeric character.
        // When we do, return false; if we don't, return true.
        for (int i = 0; i < s.length(); i++) {
            // Check that current character is number.
            char c = s.charAt(i);

            if (!isDigit(c)) return false;
        }

        // All characters are numbers.
        return true;
    }
138573
public static boolean isNumber( Object obj ) {
      if( (obj != null && obj.getClass() == Byte.TYPE)
            || (obj != null && obj.getClass() == Short.TYPE)
            || (obj != null && obj.getClass() == Integer.TYPE)
            || (obj != null && obj.getClass() == Long.TYPE)
            || (obj != null && obj.getClass() == Float.TYPE)
            || (obj != null && obj.getClass() == Double.TYPE) ){
         return true;
      }

      return obj instanceof Number;
   }
437930
private static boolean needPlural(final int n)
    {
        int tmp = 0;
        int an = Math.abs(n);

        while (an > 0)
        {
            tmp = an % 10;

            if (tmp > 1)
            {
                return true;
            }

            an /= 10;
        }

        return false;
    }
98515
public static boolean isInteger(String string) {
    if (string == null) {
      return false;
    }

    try {
      Integer.parseInt(string);
    } catch (NumberFormatException e) {
      return false;
    }

    return true;
  }