Create a min(col) expression

@param left collection
@return min(col)
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);
    }
1204773
public static <T> T min(T[] items) {
        return min((Iterable<T>)Arrays.asList(items));
    }
542862
public static Add add(Expression<Number> left, Expression<Number> right) {
        return new Add(left, right);
    }
888026
public void setLeft(AstNode left) {
        assertNotNull(left);
        this.left = left;
        // line number should agree with source position
        setLineno(left.getLineno());
        left.setParent(this);
    }
293639
function(loc, left, right) {
			var a, b;
			if (loc instanceof Range) {
				a = loc.start;
				b = loc.end;
			} else {
				a = b = loc;
			}
			
			return cmp(this.start, a, left || '<=') && cmp(this.end, b, right || '>');
		}
46191
public static <D> Predicate in(Expression<D> left, CollectionExpression<?,? extends D> right) {
        return predicate(Ops.IN, left, right);
    }
831285
public static SMARTSAtom or(IQueryAtom left, IQueryAtom right) {
        return new Disjunction(left.getBuilder(), left, right);
    }
366923
public static <L, R> Either<L, R> createLeft(L l) {
		return new Left<>(l);
	}
1173442
public static <D> Predicate notIn(Expression<D> left, Collection<? extends D> right) {
        if (right.size() == 1) {
            return neConst(left, right.iterator().next());
        } else {
            return predicate(Ops.NOT_IN, left, ConstantImpl.create(right));
        }
    }
7382
def left_outer(self):
        
        self.get_collections_data()
        left_outer_join = self.merge_join_docs(
            set(self.collections_data['left'].keys()))
        return left_outer_join
271003
function() {
            	var mins = [];

            	for(var i = 1; i <= this.rows(); i++) {
            	    var min = null;
            	    var minIndex = -1;

            	    for(var j = 1; j <= this.cols(); j++) {
            		if(min === null || this.e(i, j) < min) {
            		    min = this.e(i, j);
            		    minIndex = j;
            		}
            	    }

            	    mins.push(minIndex);
            	}

            	return $V(mins);
                }
193077
public static double min(FlatDataCollection flatDataCollection) {
        double min=Double.POSITIVE_INFINITY;
        
        Iterator<Double> it = flatDataCollection.iteratorDouble();
        while(it.hasNext()) {
            Double v = it.next();
            if(v != null && min > v) {
                min=v;
            }
        } 
        
        return min;
    }
1133214
def Min(left: vertex_constructor_param_types, right: vertex_constructor_param_types, label: Optional[str]=None) -> Vertex:
    
    return Double(context.jvm_view().MinVertex, label, cast_to_double_vertex(left), cast_to_double_vertex(right))
1277689
public DateTimeExpression<T> min() {
        if (min == null) {
            min = Expressions.dateTimeOperation(getType(), Ops.AggOps.MIN_AGG, mixin);
        }
        return min;
    }
952809
public static Short min(Short a, Short b) {
		return a <= b ? a : b;
	}
717423
public static <A extends Number & Comparable<?>> NumberExpression<A> min(Expression<A> left, Expression<A> right) {
        return Expressions.numberOperation(left.getType(), MathOps.MIN, left, right);
    }
144267
public static <A extends Comparable<? super A>> ComparableExpression<A> max(CollectionExpression<?,A> left) {
        return Expressions.comparableOperation((Class) left.getParameter(0), Ops.QuantOps.MAX_IN_COL, (Expression<?>) left);
    }