// GTE computes x >= y.
3683
func (as ArraySpec) GTE(val Input) Input {
	return as.proc(func(i Input) Input {
		return i.GTE(val)
	})
}
550413
func gte(lhs Expression, rhs interface{}) BooleanExpression {
	return boolean{op: GTE_OP, lhs: lhs, rhs: rhs}
}
22138
func (gte Gte) Or(conds ...Cond) Cond {
	return Or(gte, Or(conds...))
}
905356
func (r *RangeOp) GtOrEq(fieldName string, value interface{}) *RangeOp {
	r.appendOp(GtOrEq, fieldName, value)
	return r
}
170373
func (g GridType) Y(dataY float64) float64 {
	return g.ym*dataY + g.yb
}
712822
func (l *loopCrosser) startEdge(aj int) {
	l.crosser = NewEdgeCrosser(l.a.Vertex(aj), l.a.Vertex(aj+1))
	l.aj = aj
	l.bjPrev = -2
}
988515
func ExpectLe(x, y interface{}, errorParts ...interface{}) {
	expectThat(x, oglematchers.LessOrEqual(y), 1, errorParts)
}
437206
func (c *Carbon) Gt(carb *Carbon) bool {
	return c.After(carb.Time)
}
777483
func (g *Graph) addEqualNodes(g2 *Graph, key string, recurse bool) *Graph {
	if g2 != nil {
		for _, n := range g2.Out {
			if key == _string(n.This) {
				g.AddNodes(n)
			}
			if recurse {
				g.addEqualNodes(n, key, true)
			}
		}
	}
	return g
}
729655
func BindVariablesEqual(x, y map[string]*querypb.BindVariable) bool {
	return proto.Equal(&querypb.BoundQuery{BindVariables: x}, &querypb.BoundQuery{BindVariables: y})
}
183700
func (c C) LTE(val Input) Input {
	if v, ok := val.(C); ok {
		if c <= v {
			return C(1)
		}
		return C(0)
	}
	return val.GTE(c)
}
1335542
func GtOrEq(column string) Cmp {
	return Cmp{
		op:     geq,
		column: column,
		value:  param(column),
	}
}
1200678
func GE(m interface{}, value interface{}) (Predicate, error) {
	switch mapper := m.(type) {
	case RequestToInt:
		return intGE(mapper, value)
	case RequestToFloat64:
		return float64GE(mapper, value)
	}
	return nil, fmt.Errorf("unsupported argument: %T", m)
}
1036101
func (a *AggFuncDesc) Equal(ctx sessionctx.Context, other *AggFuncDesc) bool {
	if a.HasDistinct != other.HasDistinct {
		return false
	}
	return a.baseFuncDesc.equal(ctx, &other.baseFuncDesc)
}
623843
func _PluginAdd_Compute_GoPlugin(arg1 int, arg2 int) int {
	return p.Compute(arg1, arg2)
}
860894
func GteF(field1, field2 string) Matcher {
	return NewField2FieldMatcher(field1, field2, token.GEQ)
}
803109
func (g *Graph) assign(p *Graph, v interface{}, op int) interface{} {

	if op == '=' {
		return g.set(p, v)
	}

	// if p doesn't exist, just set it to the value given
	left, _ := g.getPath(p)
	if left != nil {
		return g.set(p, calc(left.Out[0].This, v, op))
	}

	switch op {
	case '+':
		return g.set(p, v)
	case '-':
		return g.set(p, calc(0, v, '-'))
	case '*':
		return g.set(p, 0)
	case '/':
		return g.set(p, "infinity")
	case '%':
		return g.set(p, "undefined")
	}

	return nil
}