Greater than or equal to (>=)

What it does

value1 >= value2

A >= B returns TRUE when A follows B in Excel's comparison order or is equal to it under that order, and FALSE otherwise.

The order and the equality are the family's, stated in full on FUNC.OP_EQUAL: kinds are ordered rather than coerced (number < text < logical), text comparison is case-insensitive, and numeric comparison passes through a normalization lane rather than exact IEEE comparison.

That matters because >= is the operator business logic is actually written with — minimum balances, qualifying thresholds, tier boundaries. A rule spelled >= includes values that differ from the threshold by less than the comparison layer's normalization width, whether or not the author intended a tolerance. The author cannot see this width in the formula; it comes from the comparison layer.

Arguments

Arity is exactly 2; no optional arguments, no defaults. Order is load-bearing.

Try it

Quirks

Result and edge cases

• Equal operands give TRUE, under the family's normalized, case-insensitive equality.
• Different kinds give the kind ordering; the equality half never fires across kinds. In particular ="10">=2 is TRUE because the text outranks the number, not because ten is at least two — a threshold test over a column of text-formatted numbers passes unconditionally.
• Blank operands. Context-sensitive: blank behaves as 0 against a number, "" against text, FALSE against a logical. So =A1>=0 is TRUE for an empty A1. A "did they meet the minimum?" test written with >=0 counts every empty row as a pass.
• Arrays. Ordinary broadcast with #N/A for unsupplied coordinates.

Errors

data/functions/FUNC.OP_GREATER_EQUAL.json records no Microsoft documentation URL (docs is null).

How to implement

Notes for implementers

• Derive >= from the same three-way comparison core as the other five. In particular its equality must be the family's equality, normalization and case-insensitivity included.
• Do not implement A>=B as NOT(A<B) while errors are in play; the error must propagate.
• If your comparison core normalizes, document the normalization width and direction (truncation versus rounding) as part of the implementation's contract — it is user-visible behaviour at every threshold in every workbook that uses this operator.

Rust code

CatalogueEntry::operator(
    GREATER_OR_EQUAL,
    ">=",
    Notation::Infix,
    VALUES,
    greater_or_equal,
)

fn greater_or_equal(
    arguments: &[CalcValue],
    services: &mut EvalServices<'_>,
) -> Result<CalcValue, FunctionFault> {
    compare(
        GREATER_OR_EQUAL,
        arguments,
        services,
        Want::Order,
        Ordering::is_ge,
    )
}

No implementation has been published with a Handbook test suite for this function.

Version differences

No comparison between specific Excel builds is recorded here yet. This does not establish that all builds behave alike.

Alternatives

Relationships

• FUNC.OP_GREATER_THAN — the strict form, and the operator with which >= disagrees exactly on the normalized-equality band.
• FUNC.OP_LESS_EQUAL — the mirror.
• FUNC.OP_EQUAL — the equality half.
• MATCH with match type 1, VLOOKUP/HLOOKUP in approximate mode, XLOOKUP with a next-smaller match mode — the lookup functions whose semantics are "largest value less than or equal to". Their internal comparison is their own; whether it is this operator's relation is exactly the kind of thing a vector suite would have to establish.
• COUNTIFS(range,">=5") — criteria strings, parsed by the consuming function.
• IFS, SWITCH, nested IF tier ladders — where >= chains are written, and where an off-by-one-normalization-width can put a row in the wrong tier.

Named variants

No named variants are recorded yet.