Is value of b smaller than value of a.

@return True, if b is smaller than a. Always true, if value of a is null.
492244
static boolean isSmaller(Long a, Long b) {
        return a == null || (b != null && b < a);
    }
546045
public boolean includes(double value)
    {
        return Double.compare(value, min) >= 0 && Double.compare(value, max) <= 0;
    }
162285
public static int min(int a, final int b, final int c) {
        if (b < a) {
            a = b;
        }
        if (c < a) {
            a = c;
        }
        return a;
    }
792635
function (a, b) {
            if (!a.name || !b.name) {
                return 0;
            }
            var an = a.name.toLowerCase(),
                bn = b.name.toLowerCase(),
                ret = 0;

            if (an < bn) {
                ret = -1;
            }
            if (an > bn) {
                ret = 1;
            }
            return ret;
        }
302120
private static boolean leq(int a1, int a2, int b1, int b2) {
        return (a1 < b1 || (a1 == b1 && a2 <= b2));
    }
287997
public boolean isSuperset(SmallSet<E> other) {
        if (this.list.size() < other.list.size()) {
            return false;
        }
        int j = 0;
        for (int i=0; i<list.size() && j<other.list.size(); i++) {
            E e1 = this.list.get(i);
            E e2 = other.list.get(j);
            int diff = e1.compareTo(e2);
            if (diff == 0) {
                // Equal entries. Just continue.
                j++;
                continue;
            } else if (diff > 0) {
                // e1 is greater than e2, which means e2 must not appear in this.list.
                return false;
            } else {
                // e1 is less than e2, so e2 might appear later in this.list.
                continue;
            }
        }
        if (j == other.list.size()) {
            return true;
        } else {
            return false;
        }
    }
1096533
final int compare(MutableBigInteger b) {
        int blen = b.intLen;
        if (intLen < blen)
            return -1;
        if (intLen > blen)
           return 1;

        // Add Integer.MIN_VALUE to make the comparison act as unsigned integer
        // comparison.
        int[] bval = b.value;
        for (int i = offset, j = b.offset; i < intLen + offset; i++, j++) {
            int b1 = value[i] + 0x80000000;
            int b2 = bval[j]  + 0x80000000;
            if (b1 < b2)
                return -1;
            if (b1 > b2)
                return 1;
        }
        return 0;
    }
77257
protected int isBetter2D(Box a, Box b) {
		int compare = Long.compare(a.getVolume(), b.getVolume());
		if(compare != 0) {
			return compare;
		}
		return Long.compare(b.getFootprint(), a.getFootprint()); // i.e. smaller i better
	
	}
831871
public boolean isEqual(Object value, int scale, Rounding rounding) {
		Num numA = this;
		Num numB = null;
		if (value instanceof Num)
			numB = (Num) value;
		else
			numB = new Num(value);
		
		BigDecimal a = numA.toBigDecimal();
		BigDecimal b = numB.toBigDecimal();
		
		if (rounding != null) {
			a = a.setScale(scale, rounding.getBigDecimalRound());
			b = b.setScale(scale, rounding.getBigDecimalRound());
		} else {
			a = a.setScale(scale, getProperties().getRoundingMode().getBigDecimalRound());
			b = b.setScale(scale, getProperties().getRoundingMode().getBigDecimalRound());
		}
		
		return a.equals(b);
	}
993863
public boolean greaterThan(Object left, Object right) {
    if ((left == right) || left == null || right == null) {
      return false;
    }
    else {
      return compare(left, right, ">") > 0;
    }
  }
1224500
def compare_small_comparators(other)
      return true if @size > SMALL_FILE || other.size > SMALL_FILE
      return true if small_comparator.nil? || other.small_comparator.nil?

      small_comparator.call == other.small_comparator.call
    end
1152990
public boolean hasBadValues() {
        for(int i=0; i<top; i++) {
            double v = vals[i];
            boolean bad = Double.isNaN(v) || Double.isInfinite(v);
            if(bad) return true;
        }
        return false;
    }
23644
public static final Integer compare(Object a, Object b) {
        if (a==b) return 0;
        if (a==null || b==null) return null;
        assert a!=null && b!=null;
        if (a instanceof Number && b instanceof Number) {
            Number an = (Number)a;
            Number bn = (Number)b;
            if (Double.isNaN(an.doubleValue()) || Double.isNaN(bn.doubleValue())) {
                if (Double.isNaN(an.doubleValue()) && Double.isNaN(bn.doubleValue())) return 0;
                else return null;
            } else {
                if (an.doubleValue()==bn.doubleValue()) {
                    // Long.compare(long,long) is only available since Java 1.7
                    //return Long.compare(an.longValue(),bn.longValue());
                    return Long.valueOf(an.longValue()).compareTo(Long.valueOf(bn.longValue()));
                } else {
                    return Double.compare(an.doubleValue(),bn.doubleValue());
                }
            }
        } else {
            try {
                return ((Comparable)a).compareTo(b);
            } catch (Throwable e) {
                log.debug("Could not compare elements: {} - {}",a,b);
                return null;
            }
        }
    }
498402
function (a, b) {
    if (sjcl.bitArray.bitLength(a) !== sjcl.bitArray.bitLength(b)) {
      return false;
    }
    var x = 0, i;
    for (i=0; i<a.length; i++) {
      x |= a[i]^b[i];
    }
    return (x === 0);
  }
187663
static boolean isBigger(Long a, Long b) {
        return a == null || (b != null && b > a);
    }
25059
@Override
	protected DoubleMatrix1D getLb() {
		if (this.limitedLb == null) {
			if (super.getLb() == null) {
				this.limitedLb = F1.make(getC().size(), minLBValue);
			} else {
				this.limitedLb = F1.make(super.getLb().size());
				for (int i = 0; i < super.getLb().size(); i++) {
					double lbi = super.getLb().getQuick(i);
					if (lbi < minLBValue) {
						log.warn("the " + i +"-th lower bound was limited form "+lbi+" to the value of minLBValue: " + minLBValue);
						limitedLb.setQuick(i, minLBValue);
					} else {
						limitedLb.setQuick(i, lbi);
					}
				}
			}
		}
		return limitedLb;
	}
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;
  }