final int result = (int) n; if (n != result) { throw newLossyConverionException(num, Integer.class); final double n = num.doubleValue(); if (n % 1 != 0 || n < Integer.MIN_VALUE || n > Integer.MAX_VALUE) { throw newLossyConverionException(num, Integer.class); if (!isIntegerBigDecimal(n) || n.compareTo(BIG_DECIMAL_INT_MAX) > 0 || n.compareTo(BIG_DECIMAL_INT_MIN) < 0) { throw newLossyConverionException(num, Integer.class); BigInteger n = (BigInteger) num; if (n.compareTo(BIG_INTEGER_INT_MAX) > 0 || n.compareTo(BIG_INTEGER_INT_MIN) < 0) { throw newLossyConverionException(num, Integer.class);
int firstSignum = NumberUtil.getSignum(first); int secondSignum = NumberUtil.getSignum(second); if (firstSignum != secondSignum) { return firstSignum < secondSignum ? -1 : (firstSignum > secondSignum ? 1 : 0); double firstD = first.doubleValue(); if (Double.isInfinite(firstD)) { if (NumberUtil.hasTypeThatIsKnownToNotSupportInfiniteAndNaN(second)) { return firstD == Double.NEGATIVE_INFINITY ? -1 : 1; float firstF = first.floatValue(); if (Float.isInfinite(firstF)) { if (NumberUtil.hasTypeThatIsKnownToNotSupportInfiniteAndNaN(second)) { return firstF == Float.NEGATIVE_INFINITY ? -1 : 1; double secondD = second.doubleValue(); if (Double.isInfinite(secondD)) { if (NumberUtil.hasTypeThatIsKnownToNotSupportInfiniteAndNaN(first)) { return secondD == Double.NEGATIVE_INFINITY ? 1 : -1; float secondF = second.floatValue(); if (Float.isInfinite(secondF)) { if (NumberUtil.hasTypeThatIsKnownToNotSupportInfiniteAndNaN(first)) { return secondF == Float.NEGATIVE_INFINITY ? 1 : -1;
@Override TemplateModel calculateResult(Number num, TemplateModel model) throws TemplateModelException { return NumberUtil.isInfinite(num) ? TemplateBooleanModel.TRUE : TemplateBooleanModel.FALSE; } }
if ((typeFlags & TypeFlags.MASK_KNOWN_INTEGERS) != 0 && (typeFlags & TypeFlags.MASK_KNOWN_NONINTEGERS) != 0 && NumberUtil.isIntegerBigDecimal(n) /* <- can be expensive */) { return new IntegerBigDecimal(n); } else {
public static boolean isInfinite(Number num) { if (num instanceof Double) { return ((Double) num).isInfinite(); } else if (num instanceof Float) { return ((Float) num).isInfinite(); } else if (hasTypeThatIsKnownToNotSupportInfiniteAndNaN(num)) { return false; } else { throw new UnsupportedNumberClassException(num.getClass()); } }
@Override TemplateModel calculateResult(Number num, TemplateModel model) throws TemplateModelException { return NumberUtil.isNaN(num) ? TemplateBooleanModel.TRUE : TemplateBooleanModel.FALSE; } }
@Override TemplateModel calculateResult(Number num, TemplateModel model) throws TemplateModelException { final int n; try { n = NumberUtil.toIntExact(num); } catch (ArithmeticException e) { throw new _TemplateModelException(target, "The left side operand value isn't compatible with ?", key, ": ", e.getMessage()); } if (n <= 0) { throw new _TemplateModelException(target, "The left side operand of to ?", key, " must be at least 1, but was ", Integer.valueOf(n), "."); } return new SimpleScalar(toABC(n)); }
if (NumberUtil.isIntegerBigDecimal(bd)) { return new Integer(bd.intValue()); if (NumberUtil.isIntegerBigDecimal(bd)) { return new Long(bd.longValue());
public static boolean isNaN(Number num) { if (num instanceof Double) { return ((Double) num).isNaN(); } else if (num instanceof Float) { return ((Float) num).isNaN(); } else if (hasTypeThatIsKnownToNotSupportInfiniteAndNaN(num)) { return false; } else { throw new UnsupportedNumberClassException(num.getClass()); } }
@Override TemplateModel calculateResult(Number num, TemplateModel model) throws TemplateModelException { return NumberUtil.isNaN(num) ? TemplateBooleanModel.TRUE : TemplateBooleanModel.FALSE; } }
@Override TemplateModel calculateResult(Number num, TemplateModel model) throws TemplateModelException { final int n; try { n = NumberUtil.toIntExact(num); } catch (ArithmeticException e) { throw new _TemplateModelException(target, "The left side operand value isn't compatible with ?", key, ": ", e.getMessage()); } if (n <= 0) { throw new _TemplateModelException(target, "The left side operand of to ?", key, " must be at least 1, but was ", Integer.valueOf(n), "."); } return new SimpleScalar(toABC(n)); }
final int result = (int) n; if (n != result) { throw newLossyConverionException(num, Integer.class); final double n = num.doubleValue(); if (n % 1 != 0 || n < Integer.MIN_VALUE || n > Integer.MAX_VALUE) { throw newLossyConverionException(num, Integer.class); if (!isIntegerBigDecimal(n) || n.compareTo(BIG_DECIMAL_INT_MAX) > 0 || n.compareTo(BIG_DECIMAL_INT_MIN) < 0) { throw newLossyConverionException(num, Integer.class); BigInteger n = (BigInteger) num; if (n.compareTo(BIG_INTEGER_INT_MAX) > 0 || n.compareTo(BIG_INTEGER_INT_MIN) < 0) { throw newLossyConverionException(num, Integer.class);
int firstSignum = NumberUtil.getSignum(first); int secondSignum = NumberUtil.getSignum(second); if (firstSignum != secondSignum) { return firstSignum < secondSignum ? -1 : (firstSignum > secondSignum ? 1 : 0); double firstD = first.doubleValue(); if (Double.isInfinite(firstD)) { if (NumberUtil.hasTypeThatIsKnownToNotSupportInfiniteAndNaN(second)) { return firstD == Double.NEGATIVE_INFINITY ? -1 : 1; float firstF = first.floatValue(); if (Float.isInfinite(firstF)) { if (NumberUtil.hasTypeThatIsKnownToNotSupportInfiniteAndNaN(second)) { return firstF == Float.NEGATIVE_INFINITY ? -1 : 1; double secondD = second.doubleValue(); if (Double.isInfinite(secondD)) { if (NumberUtil.hasTypeThatIsKnownToNotSupportInfiniteAndNaN(first)) { return secondD == Double.NEGATIVE_INFINITY ? 1 : -1; float secondF = second.floatValue(); if (Float.isInfinite(secondF)) { if (NumberUtil.hasTypeThatIsKnownToNotSupportInfiniteAndNaN(first)) { return secondF == Float.NEGATIVE_INFINITY ? 1 : -1;
if ((typeFlags & TypeFlags.MASK_KNOWN_INTEGERS) != 0 && (typeFlags & TypeFlags.MASK_KNOWN_NONINTEGERS) != 0 && NumberUtil.isIntegerBigDecimal(n) /* <- can be expensive */) { return new IntegerBigDecimal(n); } else {
if (NumberUtil.isInfinite(num)) { throw new NumberFormatException("It's impossible to convert an infinte value (" + num.getClass().getSimpleName() + " " + num + ") to BigDecimal.");
public static boolean isNaN(Number num) { if (num instanceof Double) { return ((Double) num).isNaN(); } else if (num instanceof Float) { return ((Float) num).isNaN(); } else if (hasTypeThatIsKnownToNotSupportInfiniteAndNaN(num)) { return false; } else { throw new UnsupportedNumberClassException(num.getClass()); } }
@Override TemplateModel calculateResult(Number num, TemplateModel model) throws TemplateModelException { return NumberUtil.isNaN(num) ? TemplateBooleanModel.TRUE : TemplateBooleanModel.FALSE; } }
@Override TemplateModel calculateResult(Number num, TemplateModel model) throws TemplateModelException { final int n; try { n = NumberUtil.toIntExact(num); } catch (ArithmeticException e) { throw new _TemplateModelException(target, "The left side operand value isn't compatible with ?", key, ": ", e.getMessage()); } if (n <= 0) { throw new _TemplateModelException(target, "The left side operand of to ?", key, " must be at least 1, but was ", Integer.valueOf(n), "."); } return new SimpleScalar(toABC(n)); }
final int result = (int) n; if (n != result) { throw newLossyConverionException(num, Integer.class); final double n = num.doubleValue(); if (n % 1 != 0 || n < Integer.MIN_VALUE || n > Integer.MAX_VALUE) { throw newLossyConverionException(num, Integer.class); if (!isIntegerBigDecimal(n) || n.compareTo(BIG_DECIMAL_INT_MAX) > 0 || n.compareTo(BIG_DECIMAL_INT_MIN) < 0) { throw newLossyConverionException(num, Integer.class); BigInteger n = (BigInteger) num; if (n.compareTo(BIG_INTEGER_INT_MAX) > 0 || n.compareTo(BIG_INTEGER_INT_MIN) < 0) { throw newLossyConverionException(num, Integer.class);
int firstSignum = NumberUtil.getSignum(first); int secondSignum = NumberUtil.getSignum(second); if (firstSignum != secondSignum) { return firstSignum < secondSignum ? -1 : (firstSignum > secondSignum ? 1 : 0); double firstD = first.doubleValue(); if (Double.isInfinite(firstD)) { if (NumberUtil.hasTypeThatIsKnownToNotSupportInfiniteAndNaN(second)) { return firstD == Double.NEGATIVE_INFINITY ? -1 : 1; float firstF = first.floatValue(); if (Float.isInfinite(firstF)) { if (NumberUtil.hasTypeThatIsKnownToNotSupportInfiniteAndNaN(second)) { return firstF == Float.NEGATIVE_INFINITY ? -1 : 1; double secondD = second.doubleValue(); if (Double.isInfinite(secondD)) { if (NumberUtil.hasTypeThatIsKnownToNotSupportInfiniteAndNaN(first)) { return secondD == Double.NEGATIVE_INFINITY ? 1 : -1; float secondF = second.floatValue(); if (Float.isInfinite(secondF)) { if (NumberUtil.hasTypeThatIsKnownToNotSupportInfiniteAndNaN(first)) { return secondF == Float.NEGATIVE_INFINITY ? 1 : -1;