第一个值是否大于第二个值

@param big 第一个值
@param small 第二个值

@return {@link Boolean}

@since 1.1.0
188481
public static boolean greatThan(Time big, Time small) {
        return compare(big, small, CompareWay.GT);
    }
460791
public int size(Key low, Key high) {
	if (low.compareTo(high) > 0)
	    return 0;
	if (contains(high))
	    return rank(high) - rank(low) + 1;
	else
	    return rank(high) - rank(low);
    }
804950
public static BigDecimal isBetweenExclusive (final BigDecimal aValue,
                                               final String sName,
                                               @Nonnull final BigDecimal aLowerBoundExclusive,
                                               @Nonnull final BigDecimal aUpperBoundExclusive)
  {
    if (isEnabled ())
      return isBetweenExclusive (aValue, () -> sName, aLowerBoundExclusive, aUpperBoundExclusive);
    return aValue;
  }
849033
private static String matchDoneBigDecimal(String bigDecimal) {
        // 对科学计数法进行处理
        boolean flg = Pattern.matches("^-?\\d+(\\.\\d+)?(E-?\\d+)?$", bigDecimal);
        if (flg) {
            BigDecimal bd = new BigDecimal(bigDecimal);
            bigDecimal = bd.toPlainString();
        }
        return bigDecimal;
    }
693925
@Override
  public long rankLong(int x) {
    long size = 0;
    short xhigh = highbits(x);
    for (int i = 0; i < this.highLowContainer.size(); i++) {
      short key = this.highLowContainer.getKeyAtIndex(i);
      int comparison = Util.compareUnsigned(key, xhigh);
      if (comparison < 0) {
        size += this.highLowContainer.getCardinality(i);
      } else if(comparison == 0) {
        return size + this.highLowContainer.getContainerAtIndex(i).rank(lowbits(x));
      }
    }
    return size;
  }
1171667
public BigInteger getBigInteger (int index) throws JSONException {
        Object object = this.get(index);
        BigInteger val = JSONObject.objectToBigInteger(object, null);
        if(val == null) {
            throw new JSONException("JSONArray[" + index +
                    "] could not convert to BigDecimal ("+ object + ").");
        }
        return val;
    }
511116
public BigInteger asBigInteger() throws IOException {
        if (_value instanceof BigInteger) {
            return (BigInteger) _value;
        }
        if (_value instanceof BigDecimal) {
            BigDecimal dec = (BigDecimal) _value;
            return dec.toBigInteger();
        }
        return BigInteger.valueOf(_value.longValue());
    }
622844
public int size(final K1 firstKey) {
		// existence check on inner map
		final HashMap<K2, HashMap<K3, V>> innerMap = map.get(firstKey);
		if( innerMap == null ) {
			return 0;
		}
		return innerMap.size();
	}
330734
private static final int mula_small(byte[] p,byte[] q,int m,byte[] x,int n,int z) {
		int v=0;
		for (int i=0;i<n;++i) {
			v+=(q[i+m] & 0xFF)+z*(x[i] & 0xFF);
			p[i+m]=(byte)v;
			v>>=8;
		}
		return v;		
	}
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
16459
public static boolean[] byte2Booleans(byte b) {
        boolean[] array = new boolean[8];
        for (int i = 7; i >= 0; i--) { //对于byte的每bit进行判定
            array[i] = (b & 1) == 1; //判定byte的最后一位是否为1，若为1，则是true；否则是false
            b = (byte) (b >> 1); //将byte右移一位
        }
        return array;
    }
1222033
public static boolean isGreaterOrEqual(BigDecimal bigNum1, BigDecimal bigNum2) {
		Assert.notNull(bigNum1);
		Assert.notNull(bigNum2);
		return bigNum1.compareTo(bigNum2) >= 0;
	}
229513
private static BigInteger bigForString(String str, int sigchars)
    {
        assert str.length() <= sigchars;

        BigInteger big = BigInteger.ZERO;
        for (int i = 0; i < str.length(); i++)
        {
            int charpos = 16 * (sigchars - (i + 1));
            BigInteger charbig = BigInteger.valueOf(str.charAt(i) & 0xFFFF);
            big = big.or(charbig.shiftLeft(charpos));
        }
        return big;
    }
1108608
public static BigRational valueOf(BigDecimal value) {
		if (value.compareTo(BigDecimal.ZERO) == 0) {
			return ZERO;
		}
		if (value.compareTo(BigDecimal.ONE) == 0) {
			return ONE;
		}
		
		int scale = value.scale();
		if (scale == 0) {
			return new BigRational(value, BigDecimal.ONE);
		} else if (scale < 0) {
			BigDecimal n = new BigDecimal(value.unscaledValue()).multiply(BigDecimal.ONE.movePointLeft(value.scale()));
			return new BigRational(n, BigDecimal.ONE);
		}
		else {
			BigDecimal n = new BigDecimal(value.unscaledValue());
			BigDecimal d = BigDecimal.ONE.movePointRight(value.scale());
			return new BigRational(n, d);
		}
	}
731743
def contains (small, large):
    
    small = to_seq (small)
    large = to_seq (large)

    for s in small:
        if not s in large:
            return False
    return True
407191
public static function calcAverage($small, $big)
    {
        $average = 0;
        if ($big != 0) {
            $x = 0;
            $y = 0;
            $average = 0;
            $x = $small / $big;
            $y = $x * 100;
            // $average = round($y); // converts to 65%
            $average = number_format((float)$y, 2, '.', '');
        }
        return $average;
    }
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;
		}
	}