DEGREES

What it does

DEGREES(angle)

DEGREES(angle) converts an angle from radians to degrees. Microsoft's page says exactly that and gives the canonical example, π radians to 180 degrees.

DEGREES(x) = x · 180 / π

There is no analysis here at all: it is one multiplication by a constant. What makes the page worth writing is that a single multiplication by an irrational constant is exactly the situation in which two obviously-equivalent formulas stop being equivalent, and this function is the cleanest example of it on the entire worksheet surface.

Arguments

Try it

Quirks

Result and edge cases

Returns Number.

• Zero — DEGREES(0) is 0, exactly, and it is the only exactly-preserved value other than the sign structure.
• DEGREES(PI()) — not exactly 180. PI() is the double nearest π, not π, so the product is the scaled image of a slightly wrong angle. Whether it rounds to 180 anyway is a question about the rounding of one multiplication, and the answer depends on which of the two op-graphs below is used. This is the single most-noticed behaviour of this function.
• DEGREES(RADIANS(x)) — not x in general. Two roundings by reciprocal irrational factors do not compose to the identity, and the round trip loses up to about one ulp.
• Underflow — for subnormal arguments the product is scaled up, so DEGREES of a subnormal is generally a normal number, and the operation recovers precision rather than losing it. This direction is harmless.

Errors

Microsoft's DEGREES page documents no error conditions.

How to implement

Numerical notes

This function has exactly one design decision, and it decides the last bit of every result.

Two op-graphs, two different functions.

(A)  result = x * (180/π)        — one rounding of the constant, one rounding of the product
(B)  result = (x * 180) / π      — `x*180` is exact when it does not overflow, then one division
(C)  result = x / (π/180)        — a third variant, with the constant rounded the other way

Form (A) rounds 180/π to a double first — an error of up to half an ulp in the constant, which becomes a relative error of up to half an ulp in every result — and then rounds the product. Two roundings, so up to one ulp of error, and the error is systematic: it has the same sign for every argument, because the constant is wrong in one fixed direction.

Form (B) multiplies by 180 first. Since 180 = 4 · 45 and 45 needs six significand bits, x * 180 is exact whenever it does not overflow — no rounding at all. Then one division by the rounded π. That is one rounding of the constant and one of the division, so nominally the same count, but the errors do not align the same way and the results differ on a substantial fraction of inputs. Form (B) also overflows earlier, at ABS(x) near 10^306, because the intermediate x*180 is larger than the result.

Form (C) divides by a differently-rounded constant again.

None of the three is "wrong"; they are three functions that agree to within an ulp and disagree in the last bit. Which one a spreadsheet uses is a fact about the spreadsheet, and it is exactly the kind of fact the Handbook exists to record. The Handbook has not determined which form Excel uses, and this page will not guess.

Why it is worth determining. DEGREES is a scaling, so its error is purely relative and constant across the range — there is no argument reduction, no cancellation, no conditioning problem anywhere. That makes it an unusually clean probe: any disagreement between two implementations is entirely attributable to the op-graph, with no confounding effects. It is the ideal warm-up target for op-graph identification, and a resolved answer here would be a model for the harder surfaces in this batch.

The correctly-rounded target. A math-correct implementation computes x · 180/π with the constant to double-double precision and rounds once. That is achievable with a two-term split of 180/π and one fused multiply-add, and it differs from all three forms above on the arguments where they are worst. Muller et al.'s Handbook of Floating-Point Arithmetic gives the technique and the analysis; Goldberg's paper gives the underlying one-rounding-versus-two argument in its standard form.

Rust code

22 degrees "DEGREES" (1, 1) [V "angle"] |s, a, sv| {
    raw(s, a, ExcelRealPolicy::FINITE, k::degrees::degrees_kernel)
}

pub fn degrees_kernel(n: f64) -> f64 {
    n * (180.0 / std::f64::consts::PI)
}

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

Version differences

The recorded environments below distinguish a reading from a same-input comparison. Counts describe captured inputs in each environment; overlapping captures and comparisons are not totals of unique worksheet calls.

• XC-DEGREES-001: build 19929 versus build 20430; 2 same-input pairs, 0 differing answers. Compared axes: excel-build. Numeric answers were compared by their recorded binary64 bits; other answers by typed value.

Agreement on these compared inputs does not establish agreement on unmeasured inputs.

Recorded environments and comparison details.

Alternatives

Relationships

• RADIANS — the inverse, y · π / 180. The pair is the standard round-trip probe and neither direction is exact.
• COS, SIN, TAN — the functions that make this one necessary, all of which take radians. Microsoft's COS page recommends RADIANS() or multiplication by PI()/180 for exactly this reason.
• PI() — the constant this function is scaled by, and the source of its irreducible error.
• ACOS, ASIN, ATAN, ATAN2 — the inverse trigonometric functions, which return radians and are therefore the usual callers of DEGREES.
• CONVERT — the general unit converter, which also handles angle units. Whether CONVERT(x, "rad", "deg") and DEGREES(x) agree bitwise is a natural question and is unchecked here.

Named variants

No named variants are recorded yet.