Returns the smaller of two {@code MonetaryAmount} values. If the arguments
have the same value, the result is that same value.
@param a an argument.
@param b another argument.
@return the smaller of {@code a} and {@code b}.
438478
static MonetaryAmount min(MonetaryAmount a, MonetaryAmount b) {
        MoneyUtils.checkAmountParameter(Objects.requireNonNull(a), Objects.requireNonNull(b.getCurrency()));
        return a.isLessThan(b) ? a : b;
    }
354578
private boolean lessThanOrEqual(
         byte[] a,
         byte[] b)
    {
         if (a.length <= b.length)
         {
             for (int i = 0; i != a.length; i++)
             {
                 int    l = a[i] & 0xff;
                 int    r = b[i] & 0xff;

                 if (r > l)
                 {
                     return true;
                 }
                 else if (l > r)
                 {
                     return false;
                 }
             }

             return true;
         }
         else
         {
             for (int i = 0; i != b.length; i++)
             {
                 int    l = a[i] & 0xff;
                 int    r = b[i] & 0xff;

                 if (r > l)
                 {
                     return true;
                 }
                 else if (l > r)
                 {
                     return false;
                 }
             }

             return false;
         }
    }
448772
public static double smallDotProduct_Double(double[] a, double[] b, int length) {
        double sumA = 0.0;
        double sumB = 0.0;
        switch (length) {
            case 7:
                sumA = a[6] * b[6];
            case 6:
                sumB = a[5] * b[5];
            case 5:
                sumA += a[4] * b[4];
            case 4:
                sumB += a[3] * b[3];
            case 3:
                sumA += a[2] * b[2];
            case 2:
                sumB += a[1] * b[1];
            case 1:
                sumA += a[0] * b[0];
            case 0:
            default:
                return sumA + sumB;
        }
    }
799548
public static <T extends Comparable<T>> T min(T obj1, T obj2) {
    return obj1.compareTo(obj2) <= 0 ? obj1 : obj2;
  }
458302
public int compare(Alternative ab) {
        if (production != ab.production) {
            throw new IllegalArgumentException();
        }
        // TODO: compare two ups
        if (resultOfs != -1 || ab.resultOfs != -1) {
            return NE;
        }
        if (argsOfs.size() == 0 && ab.argsOfs.size() == 0) {
            return EQ;
        }
        if (argsOfs.size() == 0 || ab.argsOfs.size() == 0) {
            return ALT;
        }
        if (max(argsOfs) < min(ab.argsOfs)) {
            return LT;
        }
        if (min(argsOfs) > max(ab.argsOfs)) {
            return GT;
        }
        if (argsOfs.size() != 1 || ab.argsOfs.size() != 1) {
            return NE;
        } else {
            if (argsOfs.get(0) != ab.argsOfs.get(0)) {
                throw new IllegalStateException();
            }
            return EQ;
        }
    }
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;
    }
468572
public boolean sameValue(Object value1, Object value2) {
    return ((BigDecimal)value1).compareTo((BigDecimal)value2) == 0;
  }
1194710
@Override
    public double compute(double a, double b) {
        if (Op.isLt(a + b, 1.0)) {
            return Op.max(a, b);
        }
        return 1.0;
    }
1076512
public static <T> boolean le(Comparable<T> a, T b)
	{
		return le(a.compareTo(b));
	}
64643
@Override
  public int compareTo(@Nonnull B other) {
    int length = Math.min(this.getSegments().size(), other.getSegments().size());
    for (int i = 0; i < length; i++) {
      int cmp = this.getSegments().get(i).compareTo(other.getSegments().get(i));
      if (cmp != 0) {
        return cmp;
      }
    }
    return Integer.compare(this.getSegments().size(), other.getSegments().size());
  }
1263943
@Override
  public Long min11(Long arg1, Long arg2) {
    if (arg1 == null || arg2 == null) {
      return null;
    } else {
      return Math.min(arg1, arg2);
    }
  }
74062
public SmallSet<E> diff(SmallSet<E> other) {
        SmallSet<E> tmp = new SmallSet<E>(this.size() - other.size());
        Sort.diffSortedLists(this.list, other.list, tmp.list);
        return tmp;
    }
626760
public static <T extends Comparable<? super T>> boolean lessThan(final T object, final T other) {

        return JudgeUtils.lessThan(object, other);
    }
922306
@Pure
	@Inline(value="($1 <= $2)", constantExpression=true)
	public static boolean operator_lessEqualsThan(long a, double b) {
		return a <= b;
	}
832474
public static BigInteger lcm(BigInteger a, BigInteger b) {
		return lcm(a, b, Calculator.BIG_INTEGER_CALCULATOR);
	}
1007522
public static BigDecimal min(EvaluationContext ctx, Object... args) {
        if (args.length == 0) {
            throw new RuntimeException("Wrong number of arguments");
        }

        BigDecimal result = null;
        for (Object arg : args) {
            BigDecimal _arg = Conversions.toDecimal(arg, ctx);
            result = result != null ? _arg.min(result) : _arg;
        }
        return result;
    }
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;
    }