CSC

What it does

CSC(number)

CSC(number) returns the cosecant of an angle in radians. Microsoft's page states the identity outright: CSC(n) equals 1/SIN(n).

csc x = 1 / sin x

That last row is the reader's most useful fact: CSC has no zeros, so a CSC result near zero is impossible and a CSC result of small magnitude is a bug. The function's values are bounded away from the origin and unbounded near every multiple of π.

As with COT, the poles matter less than they look. π is irrational, so the only pole that is a binary64 value is x = 0; at every other multiple of π the function returns a large finite number whose magnitude is roughly the reciprocal of the distance from the argument to the true pole.

Arguments

The slot takes ordinary to-number coercion; the surface is declared an elementwise scalar kernel. See Coercion and lifting.

Try it

Quirks

Result and edge cases

Returns Number with absolute value at least 1.

• CSC(0) — 1/SIN(0) is a division by zero. Microsoft's page does not state the resulting error, where COT's page states #DIV/0! for the analogous case. #DIV/0! follows from the documented identity, but the identity is a definition, not an error specification, and the Handbook has not checked it. Recorded as a documentation gap.
• Near other poles — a large finite value, sign alternating with the parity of k.
• ABS result below 1 — impossible mathematically. A returned value in (-1, 1) would be a defect, and this is the cheapest invariant to test.
• Beyond 2^27 — documented #NUM!.
• Small arguments — csc x → 1/x, a huge finite number, overflowing only in the subnormal range.

Errors

As documented on Microsoft's CSC page:

The zero case is not documented on that page. See the note above.

How to implement

Numerical notes

The documented identity is unusually informative, because it tells you what the error looks like without needing an oracle.

Double rounding is structural here. If CSC(x) really is 1/SIN(x) evaluated on the published binary64 sine, then the cosecant's error is the sine's relative error, inverted, plus the rounding of one division. Two consequences follow. The good one: the relative error of CSC is bounded by the relative error of SIN plus half an ulp, so CSC is never much worse than SIN in relative terms. The bad one: it is never better either, and near the poles the sine's own relative error is at its worst, because that is where sin is small and its argument reduction dominates.

The reduction problem, inherited. EV-MATH-0004 identifies the substrate as the x87 FSIN/FPTAN chain with FPREM1 reduction against the 64-bit ROM π, rules out Cody–Waite reduction against extended π, and attaches a host-CPU microcode caveat to all six circular surfaces. The record states each of the six was scored individually, so CSC is a measured surface rather than one whose status was inherited from SIN. Its figures render in the evidence layer beside this page.

Where the amplification lives. Near a pole kπ, write x = kπ + δ. Then csc x ≈ (-1)^k / δ. The reduced argument δ is computed by subtracting a stored multiple of π from x, so its absolute error is roughly ABS(x) · 2^-p for a p-bit reduction constant. The relative error of the result is therefore about ABS(x)·2^-p / ABS(δ) — it grows with the argument and blows up as the argument approaches a pole. This is the analysis that makes a documented 2^27 bound a reasonable engineering decision rather than an arbitrary one: past that magnitude the reduced argument carries no reliable bits at all.

Near zero, use 1/x + x/6 + 7x³/360 (A&S 4.3.68) rather than a division, both for speed and because it gives the deviation from 1/x directly.

A natural-best implementation would not use the published sine. It would perform one reduction, evaluate sin r in extended precision, and reciprocate before rounding — one rounding instead of two, and the pole located consistently with the reduction. That is a different function from the documented one, which is exactly why the flavour distinction in About implementation options exists.

Rust code

14 csc "CSC" (1, 1) [V "number"] |s, a, sv| { unary(s, a, k::csc::csc_kernel) }

pub fn csc_kernel(n: f64) -> Result<f64, WorksheetErrorCode> {
    ExcelRealPolicy::CIRCULAR_TRIG.check_arg(n)?;
    // W109 G4-01: CSC = RN53(RN64(1/SIN)) over the published SIN chain.
    let sin = crate::ported::excel_numeric::excel_sin(n);
    if sin == 0.0 {
        return Err(WorksheetErrorCode::Div0);
    }
    Ok(crate::ported::excel_numeric::excel_x87_recip(sin))
}

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-CSC-001: build 19929 versus build 20430; 1 same-input pairs, 0 differing answers. Compared axes: excel-build. Numeric answers were compared by their recorded binary64 bits; other answers by typed value.
• XC-CSC-002: build 20131 versus build 20430; 1 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

• SIN — the reciprocal, named by the documentation itself. EV-MATH-0004 records that the three reciprocal surfaces are built as excel_x87_recip of the published primaries, which is exactly what the documented identity CSC(n) = 1/SIN(n) describes: the reciprocal of the already-rounded binary64 sine, not an independently computed cosecant.
• SEC, COT — the other two reciprocals from the same 2013 batch, sharing the documentation template and the 2^27 bound.
• COS, TAN — the primaries. csc x = sec(π/2 - x).
• ASIN — there is no ACSC on the worksheet surface; ASIN(1/x) is the substitute.
• CSCH — the hyperbolic partner, csch x = -i·csc(ix), sharing the 1/x leading term and the pole at the origin.
• IMCSC — the complex version.

Named variants

No named variants are recorded yet.