RADIANS

What it does

RADIANS(angle)

RADIANS(angle) converts an angle from degrees to radians.

RADIANS(d) = d · π / 180

It is a linear map — multiplication by a single constant — and it exists because every trigonometric function in the worksheet takes radians while every human angle is written in degrees. The constant is

π/180 = 0.01745329251994329576923690768488...

Domain: all real numbers. Range: all real numbers. The map is a bijection on the reals with DEGREES as its exact mathematical inverse, and — this is the part that matters — not its floating-point inverse.

Arguments

Try it

Quirks

Result and edge cases

Returns Number.

• RADIANS(0) is zero, and RADIANS(-0) preserves the sign of zero in binary64 — a distinction with no worksheet consequence but a real one at the raw-return boundary; see The value universe.
• Tiny angles. The same multiplication can underflow: a subnormal input, multiplied by π/180, rounds to zero. The map is not injective at the bottom of the exponent range.
• What comes next is where the surprises live. RADIANS(90) is not π/2, because π/2 is not a double. SIN(RADIANS(90)) is therefore not exactly 1 for the same reason SIN(PI()/2) is not — though in this case the error lands in a place where sine is flat, so it is invisible. COS(RADIANS(90)) is the visible one: a small nonzero value rather than zero.

Errors

How to implement

Numerical notes

None of the three is uniformly best. The natural-best route is a two-term (double-double) representation of π/180: multiply by the high word, then correct with the low word, giving a result correctly rounded on all but a vanishing set of inputs. The cost is one extra multiply-add.

Why anyone should care. The conversion is the first operation in a trigonometric pipeline, so its error is the input error for everything downstream, and the trigonometric functions amplify argument error by the derivative. For TAN and SEC near a pole that amplification is unbounded (see SEC), so a half-ulp difference in the converted angle becomes an arbitrarily large difference in the result. Angles near 90° are exactly where engineering spreadsheets live.

The exactness that is not available. Degrees are a decimal-friendly unit and radians are not; RADIANS(90) cannot be exact, cannot be reduced exactly against π, and cannot be recovered. A library that wants exact quadrant behaviour has to keep the angle in degrees all the way to the kernel and use degree-argument trigonometric functions (sinpi/cospi-style, with the argument scaled by 1/180 exactly inside the kernel). Excel provides no such function, which is a real gap worth naming: there is no SIND, and SIN(RADIANS(30)) does not return exactly 0.5.

Rust code

23 radians "RADIANS" (1, 1) [V "angle"] |s, a, sv| {
    raw(s, a, ExcelRealPolicy::PASS, k::radians::radians_kernel)
}

pub fn radians_kernel(n: f64) -> f64 {
    let result = crate::ported::excel_numeric::excel_x87_mul(n, std::f64::consts::PI / 180.0);
    if result.abs() < f64::MIN_POSITIVE { 0.0 } else { result }
}

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-RADIANS-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

• DEGREES — the other direction, r·180/π. The pair is not a floating-point round trip: DEGREES(RADIANS(d)) returns d for many inputs and not for all, because two roundings by reciprocal-ish constants do not cancel. If a workbook needs the original degrees back, it should keep them rather than convert twice.
• The trigonometric family (SIN, COS, TAN, SEC, CSC, COT) — the consumers. SEC(RADIANS(x)) inherits the argument-magnitude guard described on SEC, but at a different input threshold, because RADIANS shrinks the argument by a factor of about 57.3 before the guard sees it.
• PI — writing x*PI()/180 by hand is the common alternative, and it is not the same computation; see the numerical notes.

Named variants

No named variants are recorded yet.