Create a {@code max(left, right)} expression

<p>Return the greater of the given values</p>

@return max(left, right)
183561
public static <A extends Number & Comparable<?>> NumberExpression<A> max(Expression<A> left, Expression<A> right) {
        return NumberExpression.max(left, right);
    }
99614
public boolean greaterThanOrEqual(Object left, Object right) {
    if (left == right) {
      return true;
    }
    else if (left == null || right == null) {
      return false;
    }
    else {
      return compare(left, right, ">=") >= 0;
    }
  }
1239534
@Override
  public Long max11(Long arg1, Long arg2) {
    if (arg1 == null || arg2 == null) {
      return null;
    } else {
      return Math.max(arg1, arg2);
    }
  }
1046319
public BoundedAssertion getMax()
    {
    ICondition max = null;
    Iterator<ICondition> conditions = getConditions();
    for( int i = 0; i < 2; i++) max = conditions.next();
    return (BoundedAssertion) max;
    }
681407
public static Constraint max(final Number max) {
		return new Constraint("max", maxPayload(max)) {
			public boolean isValid(Object actualValue) {
				return actualValue == null || (actualValue instanceof Number && max != null &&
						max.longValue() >= ((Number) actualValue).longValue());
			}
		};
	}
829554
public DateExpression<T> max() {
        if (max == null) {
            max = Expressions.dateOperation(getType(), Ops.AggOps.MAX_AGG, mixin);
        }
        return max;
    }
1139420
public static /*@pure@*/ int maxIndex(int[] ints) {

    int maximum = 0;
    int maxIndex = 0;

    for (int i = 0; i < ints.length; i++) {
      if ((i == 0) || (ints[i] > maximum)) {
	maxIndex = i;
	maximum = ints[i];
      }
    }

    return maxIndex;
  }
1210118
public com.google.api.ads.adwords.axis.v201809.cm.ComparableValue getMax() {
        return max;
    }
170918
public static <A extends Comparable<? super A>> ComparableExpression<A> min(CollectionExpression<?,A> left) {
        return Expressions.comparableOperation((Class) left.getParameter(0), Ops.QuantOps.MIN_IN_COL, (Expression<?>) left);
    }
556644
public static int max(int a, int b, int c) {
    int ma;
    ma = a;
    if (b > ma) {
      ma = b;
    }
    if (c > ma) {
      ma = c;
    }
    return ma;
  }
1288791
public static double max(DoubleArrayND array)
    {
        return array.stream().parallel().reduce(
            Double.NEGATIVE_INFINITY, Math::max);
    }
837757
public static long max(long a, final long b, final long c) {
        if (b > a) {
            a = b;
        }
        if (c > a) {
            a = c;
        }
        return a;
    }
952219
@Override
  public IVersion getMaximum()
  {
    Iterator<IVersionRange> it = ranges.iterator();
    IVersionRange r1 = it.next();
    IVersion max = r1.getMaximum();

    while (it.hasNext()) {
      IVersionRange r2 = it.next();
      IVersion v2 = r2.getMinimum();
      int cmp = max.compareTo(v2);
      if (cmp > 0) {
        return max = v2;
      }
    }

    return max;
  }
1346307
public float max(float... values) {
        float max = Float.MIN_VALUE;
        for (int i = 0; i < values.length; i++) {
            if (i == 0 || values[i] > max) {
                max = values[i];
            }
        }
        
        return max;
    }
1188647
public static int whichMax(float[] x) {
        float m = Float.NEGATIVE_INFINITY;
        int which = 0;

        for (int i = 0; i < x.length; i++) {
            if (x[i] > m) {
                m = x[i];
                which = i;
            }
        }

        return which;
    }
396787
@Override
    public long getMaxX() {
        if (!excludeOutOfRangeValues) {
            return super.getMaxX();
        } else {
            long retMax = 0;
            Iterator<Long> iter = values.keySet().iterator();

            if (iter.hasNext()) {
                retMax = iter.next();
            }
            long excludeValue = getGranulationValue() * excludeCount;
            while (iter.hasNext()) {
                long value = iter.next();

                if (value > retMax) {
                    if ((value - retMax) < excludeValue) {
                        retMax = value;
                    }
                }
            }
            return retMax;
        }
    }
15798
public static double elementMax( DMatrix4 a ) {
        double max = a.a1;
        if( a.a2 > max ) max = a.a2;
        if( a.a3 > max ) max = a.a3;
        if( a.a4 > max ) max = a.a4;

        return max;
    }