// Lt is used to express a "less than" constraint for a range query
335244
func (r *RangeOp) Lt(fieldName string, value interface{}) *RangeOp {
	r.appendOp(Lt, fieldName, value)
	return r
}
493465
func (brh blockRetrievalHeap) Less(i, j int) bool {
	reqI := brh[i]
	reqJ := brh[j]
	if reqI.priority > reqJ.priority {
		return true
	}
	if reqI.priority < reqJ.priority {
		return false
	}
	return reqI.insertionOrder < reqJ.insertionOrder
}
661639
func (p *iisQueryProperty) LessThan(value interface{}) *iisQueryBuilder {
	p.bldr.q = p.bldr.q.Filter(p.name+" <", value)
	if p.bldr.plugin != nil {
		p.bldr.plugin.Filter(p.name, "<", value)
	}
	return p.bldr
}
894379
func (p *fooBarQueryProperty) LessThan(value interface{}) *fooBarQueryBuilder {
	p.bldr.q = p.bldr.q.Filter(p.name+" <", value)
	if p.bldr.plugin != nil {
		p.bldr.plugin.Filter(p.name, "<", value)
	}
	return p.bldr
}
1255510
func (d *Duration) Lt(value time.Duration) *Duration {
	if d.value == nil {
		d.chain.fail("expected duration is set, but it is not")
		return d
	}
	if !(*d.value < value) {
		d.chain.fail("\nexpected duration < then:\n %s\n\nbut got:\n %s",
			value, *d.value)
	}
	return d
}
192044
func (f *fragment) rangeBetween(bitDepth uint, predicateMin, predicateMax uint64) (*Row, error) {
	b := f.row(uint64(bitDepth))
	keep1 := NewRow() // GTE
	keep2 := NewRow() // LTE

	// Filter any bits that don't match the current bit value.
	for i := int(bitDepth - 1); i >= 0; i-- {
		row := f.row(uint64(i))
		bit1 := (predicateMin >> uint(i)) & 1
		bit2 := (predicateMax >> uint(i)) & 1

		// GTE predicateMin
		// If bit is set then remove all unset columns not already kept.
		if bit1 == 1 {
			b = b.Difference(b.Difference(row).Difference(keep1))
		} else {
			// If bit is unset then add columns with set bit to keep.
			// Don't bother to compute this on the final iteration.
			if i > 0 {
				keep1 = keep1.Union(b.Intersect(row))
			}
		}

		// LTE predicateMin
		// If bit is zero then remove all set bits not in excluded bitmap.
		if bit2 == 0 {
			b = b.Difference(row.Difference(keep2))
		} else {
			// If bit is set then add columns for set bits to exclude.
			// Don't bother to compute this on the final iteration.
			if i > 0 {
				keep2 = keep2.Union(b.Difference(row))
			}
		}
	}

	return b, nil
}
934372
func (l reflectWithStringSlice) Less(i, j int) bool {
	return l[i].s < l[j].s
}
1230095
func ge(arg1, arg2 interface{}) (bool, error) {
	// >= is the inverse of <.
	lessThan, err := lt(arg1, arg2)
	if err != nil {
		return false, err
	}
	return !lessThan, nil
}
690789
func (v *Validator) Less(field string, value float64) *ValidationResult {
	return v.inequality(field, value, less, "less than")
}
911153
func (c *Carbon) Lt(carb *Carbon) bool {
	return c.Before(carb.Time)
}
997039
func (q *NumericRangeQuery) Min(min float32, inclusive bool) *NumericRangeQuery {
	q.options["min"] = min
	q.options["inclusive_min"] = inclusive
	return q
}
35750
func (r Range) Apply(q *datastore.Query) *datastore.Query {
	if r.Start != nil {
		q = q.Gt("__key__", r.Start)
	}
	if r.End != nil {
		q = q.Lte("__key__", r.End)
	}
	return q
}
1234817
func lt(m interface{}, value interface{}) (hpredicate, error) {
	switch mapper := m.(type) {
	case toInt:
		return intLT(mapper, value)
	}
	return nil, fmt.Errorf("unsupported argument: %T", m)
}
532199
func (tr Ranges) Len() int {
	if tr.sortedRanges == nil {
		return 0
	}
	return tr.sortedRanges.Len()
}
169861
func (f Frequencies) Less(i, j int) bool {
	return f[i].TFIDF < f[j].TFIDF
}
1038984
func (f *Field) Range(name string, op pql.Token, predicate int64) (*Row, error) {
	// Retrieve and validate bsiGroup.
	bsig := f.bsiGroup(name)
	if bsig == nil {
		return nil, ErrBSIGroupNotFound
	} else if predicate < bsig.Min || predicate > bsig.Max {
		return nil, nil
	}

	// Retrieve bsiGroup's view.
	view := f.view(viewBSIGroupPrefix + name)
	if view == nil {
		return nil, nil
	}

	baseValue, outOfRange := bsig.baseValue(op, predicate)
	if outOfRange {
		return NewRow(), nil
	}

	return view.rangeOp(op, bsig.BitDepth(), baseValue)
}
597681
func (r *RemoveRangeOp) Lt(fieldName string, value interface{}) *RemoveRangeOp {
	r.appendOp(Lt, fieldName, value)
	return r
}