ACOT in Calligra Sheets: Inverse Cotangent Examples and Quadrants

The ACOT function returns the principal inverse cotangent angle (radians) corresponding to a real-number cotangent input. A quick reproducible example is =DEGREES(ACOT(1)), whose independently calculated expected result is approximately 45°. This result has not been observed by executing a formula in a native Calligra Sheets installation. [E1, E2, E3]

The rule is π/2 − arctan(x). A numeric cotangent value (any finite real x); the returned principal angle lies strictly between 0 and π radians. The pinned Calligra source, not merely a similar function in Excel, is the basis for the syntax and interpretation described here. [E1, E2]

=ACOT(number)

• Required argument (one): Input is a cotangent ratio (dimensionless), output is an angle in radians. The Calligra 26.08.2 XML has one <Parameter> of type Float; the function is registered without an extra optional argument or default. The official XML syntax is ACOT(Float). [E1, E2]
• Return: a floating-point number. The XML return type is Float and the pinned implementation is a floating calculation. [E1, E2]
• Spreadsheet entry: type the initial = before the function. These examples use the English KDE documentation convention: decimal point and semicolon between arguments in multi-argument formulas (for example =ROUND(ACOT(0);6)). Decimal and list separators can vary with operating locale; confirm them in the user’s installation rather than replacing commas or semicolons blindly. [E1]
• Verified scope: Calligra 26.08.2, released 2026-10-08, at pinned revision 72123cc643f6625351139e7df294544255a1056f; source/documentation accessed 2026-10-12. This proves registration and source semantics for that release, not actual behavior of an installed distribution package or particular OS. [E1, E2, E5]

Mathematical domain/limits: a numeric cotangent value (any finite real x); the returned principal angle lies strictly between 0 and π radians. There is no finite real-input singularity in the formula π/2 − arctan(x); acot(0) is valid and returns π/2. Native displayed error messages and package-specific numerical limits are not established by this guide. [E2, E3]

In A1 enter Cotangent input, B1 enter ACOT result (radians), and C1 enter Result (degrees). Enter the six numeric cotangent values in A2:A7. In B2 enter =ACOT(A2) and fill to B7; in C2 enter =DEGREES(B2) and fill to C7. The final input 1.3333333333 may be entered as =8/6 to avoid rounding the ratio manually. [E1, E3]

How to check the results: With input 0, source code evaluates π/2 − atan(0) = π/2, so the expected angle is 90°. Input 1 gives π/4 = 45°; input −1 gives 3π/4 = 135°. Input 2 gives about 26.56505118°, and −2 gives about 153.43494882°. All calculated results are expected approximate numbers based on Python’s independent standard-library trigonometric functions, not observations in Calligra. Differences of a few trailing digits are normal with floating-point evaluation. [E3]

Practical formula check

Understand the quadrant: Because the pinned source implements PI()/2 - ATAN(x), negative cotangent inputs produce principal angles greater than 90°, unlike ATAN(1/x) if used naively. ACOT is not a general 360° directional-angle tool; angle reconstruction from signed x/y coordinates may require a properly oriented ATAN2 formulation. For user-facing degrees, =DEGREES(ACOT(A2)) is clearer than assuming the ACOT result is already measured in degrees. [E2, E3]

In a right triangle with an adjacent side of 8 and an opposite side of 6, the cotangent of the acute angle is 8/6. Set E2=8 (adjacent) and F2=6 (opposite). Enter =DEGREES(ACOT(E2/F2)) in G2. The expected angle is 36.86989765°, matching =DEGREES(ATAN(F2/E2)) for positive nonzero sides. If F2=0, the ratio E2/F2 is undefined: do not hide that upstream division error by treating it as a valid ACOT input. [E3]

• Misleading XML parameter note: The pinned KDE XML lists Angle (radians) as the parameter comment, yet the source calculates π/2 − atan(input) and Excel defines the input as a cotangent value. Treat the numeric input as a ratio, not an already-known angle; the return value is in radians. This is a metadata inconsistency; the source defines the calculation shown here. [E2, E3]
• Using ATAN(1/x) as a replacement: The expression fails at x=0 and selects the wrong principal branch for negative x. Use the verified source expression (π/2 − atan(x)) when explaining the mathematics. [E2, E3]
• Assuming output in degrees: =ACOT(1) returns approximately 0.7853981634 radians, not the number 45. Wrap it in DEGREES() for 45°. [E2, E3]
• Invalid input or coercion: The XML requests one float. Strings, blanks, infinities, malformed references, actual application error labels and locale coercion are not native-tested. [E2, E3]
• Large positive/negative values: The output mathematically approaches 0 as x→+∞ and approaches π as x→−∞, but does not attain either endpoint for a finite real input. Numerical saturation/precision for extreme machine-size values was not tested. [E2, E3]

Excel documents ACOT(number) where number is the cotangent of the angle; its result is in radians on the interval 0 to π (endpoints excluded). This matches the pinned Calligra source formula for ordinary numeric examples. However, the Calligra XML parameter comment misleadingly calls the input an angle, and neither its numerical coercion nor its displayed error behavior has been checked in native Calligra. Excel-specific #VALUE! details must not be presented as Calligra execution evidence. [E2, E4]

Portability checklist: make a local copy of your workbook; verify radians versus degrees; check decimal/list separators; compare a simple expected result; deliberately test boundary/error cases in the destination program before relying on a high-stakes numerical result. This guide does not claim an Excel or LibreOffice runtime test.

Can I use degrees directly? No. ACOT accepts a cotangent ratio, and its result is radians. Use DEGREES(ACOT(x)) to convert the output.

Is the result exact? No promise of bit-for-bit equality is made. These functions use floating point; table figures are rounded expected values. [E2, E3]

What happens at problematic values? There is no finite real-input singularity in the formula π/2 − arctan(x); acot(0) is valid and returns π/2. If a formula produces a surprising number or displayed error, confirm it on native Calligra and check the exact input units and numeric precision. The source wrapper is not a native screen test. [E2]

ATAN is used by the pinned implementation; DEGREES converts returned radians; RADIANS converts known angle measures in the other direction; COT (registered in the pinned release) is the forward cotangent where defined; ATAN2 can help with coordinate quadrants but its argument ordering must be checked independently. [E1, E2]

Read the official KDE Sheets function reference for current HTML help, the pinned Calligra 26.08.2 function definitions for declared syntax and the pinned implementation for source-level behavior. These are official external links, checked 2026-10-12. [E1, E2]

[E1] KDE official Sheets function handbook — ACOT and the pinned 26.08.2 XML (function entry around L23-L35), accessed 2026-10-12; official one-argument syntax/type and supplied examples.

[E2] Pinned 26.08.2 C++ implementation and registration, verified 2026-10-12. Source-inferred behavior, not native execution. The pinned release wrapper computes calc->sub(calc->div(calc->pi(), 2), calc->atg(args[0])). The function XML parameter description says Angle (radians) but implementation and Microsoft function documentation show the argument is a cotangent number; this conflict is flagged. No extrapolation to text-input behavior.

[E3] Independent calculations using Python 3 standard-library math with the exact input values shown above; expected numbers only.

[E4] Microsoft official Excel ACOT documentation, accessed 2026-10-12, used for claims about Excel, not to infer Calligra error semantics.

[E5] KDE Gear 26.08.2 release announcement, dated 2026-10-08; pinned source revision 72123cc643f6625351139e7df294544255a1056f.

Validation: Official documentation and version-pinned source reviewed; examples independently calculated. No native Calligra execution was performed.