Is value of b bigger than value of a.

@return True, if b is bigger than a. Always true, if value of a is null.
187663
static boolean isBigger(Long a, Long b) {
        return a == null || (b != null && b > a);
    }
352462
public boolean isSameOrNewerThan(JavaVersion other) {
        return this.major > other.major || (this.major == other.major && this.minor >= other.minor);
    }
83633
private boolean hasStableSize() {
		try {
			Integer.parseInt(getWidthAsString());
			int width = getWidth();
			int height = getHeight();
			// compare with previous size and return true if same
			if (previousWidth != width || previousHeight != height) {
				// force small size (workaround for smartgwt problem where size can otherwise not shrink below the
				// previous size)
				vectorContext.setSize(EventWidget.INITIAL_SIZE, EventWidget.INITIAL_SIZE);
				eventWidget.setInitialSize();
				previousWidth = width;
				previousHeight = height;
				return false;
			} else {
				return true;
			}
		} catch (NumberFormatException e) {
			return false;
		}
	}
179460
private boolean checkEquality(HashMap<String, Double> a,
			HashMap<String, Double> b) {
		for(String s: a.keySet()){
			if(Double.compare(a.get(s), b.get(s)) != 0)
				return false;
		}
		return true;
	}
331362
function BigInteger(a, b) {
    if (a != null) {
        if ("number" == typeof a) {
            this.fromNumber(a, b);
        } else if (Buffer.isBuffer(a)) {
            this.fromBuffer(a);
        } else if (b == null && "string" != typeof a) {
            this.fromByteArray(a);
        } else {
            this.fromString(a, b);
        }
    }
}
965865
public static boolean isGreater(BigDecimal bigNum1, BigDecimal bigNum2) {
		Assert.notNull(bigNum1);
		Assert.notNull(bigNum2);
		return bigNum1.compareTo(bigNum2) > 0;
	}
145743
public boolean greaterThan(long val) {
        if (isInfinity && posOrNeg) {
            return true;
        } else if (isInfinity && !posOrNeg) {
            return false;
        } else {
            return this.val > val;
        }
    }
951264
private static boolean isLong( Number n ) {
      if( n instanceof Long ){
         return true;
      }
      try{
         Long.parseLong( String.valueOf( n ) );
         return true;
      }catch( NumberFormatException e ){
         return false;
      }
   }
213798
public static BigRational valueOf(BigInteger value) {
		if (value.compareTo(BigInteger.ZERO) == 0) {
			return ZERO;
		}
		if (value.compareTo(BigInteger.ONE) == 0) {
			return ONE;
		}
		return valueOf(value, BigInteger.ONE);
	}
1089530
public static boolean isValueEquals(BigDecimal decimal1, BigDecimal decimal2) {
		if (decimal1 == null && decimal2 == null) return true;
		if (decimal1 == null && decimal2 != null) return false;
		if (decimal1 != null && decimal2 == null) return false;
		return cutInvalidSacle(decimal1).equals(cutInvalidSacle(decimal2));
	}
424928
private boolean isValueOutOfRange(final Double value) {
        return value == null || getMinValue() != Double.NEGATIVE_INFINITY && value < getMinValue()
                || getMaxValue() != Double.POSITIVE_INFINITY && value > getMaxValue();
    }
1012232
public static double max(final double a, final double b) {
        if (a > b) {
            return a;
        }
        if (a < b) {
            return b;
        }
        /* if either arg is NaN, return NaN */
        if (a != b) {
            return Double.NaN;
        }
        /* min(+0.0,-0.0) == -0.0 */
        /* 0x8000000000000000L == Double.doubleToRawLongBits(-0.0d) */
        long bits = Double.doubleToRawLongBits(a);
        if (bits == 0x8000000000000000L) {
            return b;
        }
        return a;
    }
1094562
private static boolean numbersEqual(Number a, Number b) {
        if (a.equals(b)) {
            return true;
        }
        if (a.doubleValue() == b.doubleValue()) {
            return true;
        }
        return false;
    }
82598
protected boolean valuesEqual(byte[] oldValue, byte[] newValue) {
    return (oldValue == null && newValue == null)
        || (oldValue != null && newValue != null && Arrays.equals(oldValue, newValue));
  }
78061
public static float max(final float a, final float b) {
        if (a > b) {
            return a;
        }
        if (a < b) {
            return b;
        }
        /* if either arg is NaN, return NaN */
        if (a != b) {
            return Float.NaN;
        }
        /* min(+0.0,-0.0) == -0.0 */
        /* 0x80000000 == Float.floatToRawIntBits(-0.0d) */
        int bits = Float.floatToRawIntBits(a);
        if (bits == 0x80000000) {
            return b;
        }
        return a;
    }
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;
  }
544910
private static boolean isBigInteger( Number n ) {
      if( n instanceof BigInteger ){
         return true;
      }
      try{
         new BigInteger( String.valueOf( n ) );
         return true;
      }catch( NumberFormatException e ){
         return false;
      }
   }