Returns {@code true} if {@code x} represents a mathematical integer.

<p>This is equivalent to, but not necessarily implemented as, the expression {@code
!Double.isNaN(x) && !Double.isInfinite(x) && x == Math.rint(x)}.
552128
public static boolean isMathematicalInteger(double x) {
        return isFinite(x) && (x == 0.0 || SIGNIFICAND_BITS - Long.numberOfTrailingZeros(getSignificand(x)) <= getExponent(x));
    }
158861
public static boolean isIntValue(final String value) {
        try {
            Integer.parseInt(value);
            return true;
        } catch (final NumberFormatException ex) {
            return false;
        }
    }
397611
@Pure
	public static double fromESRI_x(double x) throws IOException {
		if (Double.isInfinite(x) || Double.isNaN(x)) {
			throw new InvalidNumericValueException(x);
		}
		return x;
	}
1040761
static boolean isAlphanum(int c) {
		return ( (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || 
				 (c >= 'A' && c <= 'Z') || c == '_' || c == '$' || c == '\\' || 
				 c > 126);
	}
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;
    }
573124
@Pure
	@Inline(value = "Math.abs($1) < Math.ulp($1)", imported = Math.class)
	public static boolean isEpsilonZero(double value) {
		return Math.abs(value) < Math.ulp(value);
	}
1312151
function isInt(value) {
  if (isNaN(value) || exports.isString(value)) {
    return false;
  }
  var x = parseFloat(value);
  return (x | 0) === x;
}
1208360
public boolean isNumber(Object value) {

        if(value == null) {
            return false;
        }

        if(value instanceof Number) {
            return true;
        }

        // valid Long?
        if(String.valueOf(value).matches("\\d+")) {
            return true;
        }

        try {
            // valid Double?
            Double.parseDouble(String.valueOf(value));
        } catch(Exception e) {
            return false;
        }

        return true;
    }
1327749
def value_is_int(self):
        """"""
        try:
            a = float(self.value)
            b = int(a)
        except ValueError:
            return False
        else:
            return a == b
1340802
public boolean isInfinite() {
        return Float.isInfinite(x) && Float.isInfinite(y) && Float.isInfinite(z);
    }
529783
public static boolean isNumeric(String s)
    {
        boolean ret = true;
        for(int i = 0; i < s.length() && ret; i++)
        {
            char c = s.charAt(i);
            ret = (c >= '0' && c <= '9');
        }
        return ret;
    }
1039067
private static boolean isNumericType(Class<?> c) {
    return Number.class.isAssignableFrom(c)
        || double.class == c
        || float.class == c
        || long.class == c
        || int.class == c
        || short.class == c
        || byte.class == c;
  }
365430
public boolean containsDouble(double value) {
		boolean isNan = Double.isNaN(value);
		for (int i = 1; i < maxPoolSize; i++) {
			if (types[i] == DOUBLE) {
				double d = readDouble(i);
				if (d == value || (isNan && Double.isNaN(d))) return true;
			}
		}
		return false;
	}
852416
public static boolean looksLikeInteger(final String value) {
    final int n = value.length();
    for (int i = 0; i < n; i++) {
      final char c = value.charAt(i);
      if (c == '.' || c == 'e' || c == 'E') {
        return false;
      }
    }
    return true;
  }
188508
public static boolean sameZero(Object x, Object y) {
        if (!typeof(x).equals(typeof(y))) {
            return false;
        }
        if (x instanceof Number) {
            if (isNaN(x) && isNaN(y)) {
                return true;
            }
            final double dx = ((Number)x).doubleValue();
            if (y instanceof Number) {
                final double dy = ((Number)y).doubleValue();
                if (((dx == negativeZero) && (dy == 0.0)) ||
                    ((dx == 0.0) && dy == negativeZero)) {
                        return true;
                }
            }
            return eqNumber(dx, y);
        }
        return eq(x, y);
    }
98515
public static boolean isInteger(String string) {
    if (string == null) {
      return false;
    }

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

    return true;
  }
1240870
public static boolean isInteger (String value)
    {
        try {
            Integer.parseInt(value);
            return true;
        } catch (NumberFormatException nfe) {
            // fall through
        }
        return false;
    }