IMCOSH
Quirk foundCategory: Engineering · Last tested 2026-09-01
Real compatibility results for the IMCOSH function: executed in Excel for the web, Google Sheets and LibreOffice Calc, with desktop Excel behavior from Microsoft’s official documentation (we do not run desktop Excel — Excel for the web is a different application and is executed separately). Syntax and links to that documentation are below.
Support matrix
| Engine | Documented | Live-tested | Verdict |
|---|---|---|---|
| Excel (desktop) | Yes | No — documented only | n/a |
| Excel for the web | — | Yes (recalc, 2026-09-01) | Supported, behaves as documented |
| Google Sheets | Yes | Yes (Drive import, 2026-08-31) | Quirk found |
| LibreOffice Calc | Yes | Yes (25.8.7.3, 2026-08-31) | Unsupported (not recognized) |
LibreOffice version history
We executed the same test cases under each LibreOffice release to show exactly when IMCOSH’s support changed — not documentation claims, real results.
| LibreOffice version | Verdict | Tested |
|---|---|---|
| 24.2.0.3 | Unsupported (not recognized) | 2026-08-31 |
| 24.8.7.2 | Unsupported (not recognized) | 2026-08-31 |
| 25.2.0.3 | Unsupported (not recognized) | 2026-08-31 |
| 25.8.7.3 | Unsupported (not recognized) | 2026-08-31 |
Why isn't IMCOSH working in LibreOffice?
IMCOSH comes back as a #NAME?
(unrecognized function) error in LibreOffice Calc 25.8.7.3 in our executed tests — but not
because the function is missing. This is not a typo or a settings problem. LibreOffice does implement this function — typed on its own, =IMCOSH(…) evaluates correctly on every release we tested — but its .xlsx importer does not recognise the _xlfn.IMCOSH token that Excel writes into the file for it, so an Excel-authored workbook opens here with #NAME?. The gap is in the file-format mapping, not in the function.
The same formula is documented for Excel and documented for Google Sheets.
Watch the LibreOffice version support page —
we re-run every test on each new release, so it will flip to Supported here as soon as it lands.
Why isn’t IMCOSH working in Google Sheets?
IMCOSH runs in Google Sheets, but our executed cases show it does not match
Excel’s documented behavior on every input (the failing cases are listed on this page). If a
formula that behaves one way in Excel gives you a different answer in Sheets, compare your usage
against those cases before assuming your data is wrong.
Discovered quirks
-
=IMCOSH(TRUE) on
Google Sheets returned
#NUM!, but the documented/expected
result is #VALUE!.
Provenance
Excel documents: "If inumber is a logical value, IMCOSH returns the #VALUE! error value." A deliberate refusal to coerce -- TRUE becomes 1 in nearly every other numeric context. STORAGE-FORM GAP, and NOT a missing capability -- the distinction is the whole point of this case. IMCOSH is an Excel 2013 addition, so real Excel does not store it in a .xlsx under its plain name: Microsoft's XLSX-extensions future-function list (the reference this harness has used since batch A, mirrored in XlsxWriter's "Formulas added in Excel 2010 and later" table) gives the storage token as _xlfn.IMCOSH, alongside _xlfn.IMCOSH, _xlfn.IMCOT, _xlfn.IMCSC, _xlfn.IMCSCH, _xlfn.IMSEC, _xlfn.IMSECH, _xlfn.IMSINH and _xlfn.IMTAN. harness/xlfn_map.py therefore writes _xlfn.IMCOSH here, exactly as Excel would. EXECUTED RESULT: all four LibreOffice builds (24.2.0.3, 24.8.7.2, 25.2.0.3, 25.8.7.3) return #NAME? for that token. A five-spelling probe pins down what this is: _xlfn.IMCOSH, COM.MICROSOFT.IMCOSH, ORG.OPENOFFICE.IMCOSH and _xlfn.ORG.OPENOFFICE.IMCOSH are all #NAME? on every build, while the UNPREFIXED IMCOSH(...) evaluates on every build and returns exactly the string asserted here, byte for byte. So LibreOffice implements IMCOSH correctly, and its OOXML import simply has no mapping for the _xlfn.IMCOSH token Excel writes -- meaning a workbook saved by Excel that uses IMCOSH arrives in LibreOffice as #NAME? even though LibreOffice could compute it. This is the exact mirror image of batch B's COT/COTH/CSC/CSCH finding, where the _xlfn. token was the ONLY spelling LibreOffice accepted, and it is recorded here as its own divergence class rather than as an ordinary unsupported-function result.; MISMATCH vs expected: expected '#VALUE!', got '#NUM!'
-
=IMCOSH("4+3i") on
LibreOffice Calc returned
#NAME?, but the documented/expected
result is -27.0349456030742+3.85115333481178i.
Provenance
Microsoft publishes '=IMCOSH("4+3i")' with the result -27.0349456030742+3.85115333481178i. Derived independently with mpmath at 40 digits from cosh(x+yi) = cosh(x)cos(y) + i*sinh(x)sin(y): cosh(4)cos(3) = -27.034945603074224648 and sinh(4)sin(3) = 3.8511533348117775366, then rendered through this corpus's own implementation of Excel's complex-string format, which reproduces the published string byte for byte. EXCEL'S COMPLEX-STRING FORMAT, which this corpus derives rather than assumes: a result is rendered as the real part, then the sign, then the imaginary coefficient followed by the suffix, with each part printed to at most 15 significant digits and trailing zeros stripped; a zero real part is omitted entirely, a zero imaginary part reduces the result to a bare real number, and an imaginary coefficient of exactly 1 or -1 prints as "i" / "-i" with no digit. That rule was not taken on faith -- it was written as a formatter in Python and validated against SEVEN independently published Microsoft strings in this batch alone (IMCOS, IMCOSH, IMCOT, IMCSC, IMCSCH, IMEXP and IMLN), which it reproduces byte for byte, before being used to predict any value this corpus asserts. String results are compared exactly, so a formatting-only difference (a trailing zero, "1i" for "i", a different digit count) fails the case and is recorded as its own divergence class, separate from a wrong numeric value. STORAGE-FORM GAP, and NOT a missing capability -- the distinction is the whole point of this case. IMCOSH is an Excel 2013 addition, so real Excel does not store it in a .xlsx under its plain name: Microsoft's XLSX-extensions future-function list (the reference this harness has used since batch A, mirrored in XlsxWriter's "Formulas added in Excel 2010 and later" table) gives the storage token as _xlfn.IMCOSH, alongside _xlfn.IMCOSH, _xlfn.IMCOT, _xlfn.IMCSC, _xlfn.IMCSCH, _xlfn.IMSEC, _xlfn.IMSECH, _xlfn.IMSINH and _xlfn.IMTAN. harness/xlfn_map.py therefore writes _xlfn.IMCOSH here, exactly as Excel would. EXECUTED RESULT: all four LibreOffice builds (24.2.0.3, 24.8.7.2, 25.2.0.3, 25.8.7.3) return #NAME? for that token. A five-spelling probe pins down what this is: _xlfn.IMCOSH, COM.MICROSOFT.IMCOSH, ORG.OPENOFFICE.IMCOSH and _xlfn.ORG.OPENOFFICE.IMCOSH are all #NAME? on every build, while the UNPREFIXED IMCOSH(...) evaluates on every build and returns exactly the string asserted here, byte for byte. So LibreOffice implements IMCOSH correctly, and its OOXML import simply has no mapping for the _xlfn.IMCOSH token Excel writes -- meaning a workbook saved by Excel that uses IMCOSH arrives in LibreOffice as #NAME? even though LibreOffice could compute it. This is the exact mirror image of batch B's COT/COTH/CSC/CSCH finding, where the _xlfn. token was the ONLY spelling LibreOffice accepted, and it is recorded here as its own divergence class rather than as an ordinary unsupported-function result.; MISMATCH vs expected: expected '-27.0349456030742+3.85115333481178i', got '#NAME?'
-
=IMCOSH(TRUE) on
LibreOffice Calc returned
#NAME?, but the documented/expected
result is #VALUE!.
Provenance
Excel documents: "If inumber is a logical value, IMCOSH returns the #VALUE! error value." A deliberate refusal to coerce -- TRUE becomes 1 in nearly every other numeric context. STORAGE-FORM GAP, and NOT a missing capability -- the distinction is the whole point of this case. IMCOSH is an Excel 2013 addition, so real Excel does not store it in a .xlsx under its plain name: Microsoft's XLSX-extensions future-function list (the reference this harness has used since batch A, mirrored in XlsxWriter's "Formulas added in Excel 2010 and later" table) gives the storage token as _xlfn.IMCOSH, alongside _xlfn.IMCOSH, _xlfn.IMCOT, _xlfn.IMCSC, _xlfn.IMCSCH, _xlfn.IMSEC, _xlfn.IMSECH, _xlfn.IMSINH and _xlfn.IMTAN. harness/xlfn_map.py therefore writes _xlfn.IMCOSH here, exactly as Excel would. EXECUTED RESULT: all four LibreOffice builds (24.2.0.3, 24.8.7.2, 25.2.0.3, 25.8.7.3) return #NAME? for that token. A five-spelling probe pins down what this is: _xlfn.IMCOSH, COM.MICROSOFT.IMCOSH, ORG.OPENOFFICE.IMCOSH and _xlfn.ORG.OPENOFFICE.IMCOSH are all #NAME? on every build, while the UNPREFIXED IMCOSH(...) evaluates on every build and returns exactly the string asserted here, byte for byte. So LibreOffice implements IMCOSH correctly, and its OOXML import simply has no mapping for the _xlfn.IMCOSH token Excel writes -- meaning a workbook saved by Excel that uses IMCOSH arrives in LibreOffice as #NAME? even though LibreOffice could compute it. This is the exact mirror image of batch B's COT/COTH/CSC/CSCH finding, where the _xlfn. token was the ONLY spelling LibreOffice accepted, and it is recorded here as its own divergence class rather than as an ordinary unsupported-function result.; MISMATCH vs expected: expected '#VALUE!', got '#NAME?'
-
=IMCOSH("abc") on
LibreOffice Calc returned
#NAME?, but the documented/expected
result is #NUM!.
Provenance
Excel documents: "If inumber is a value that is not in the x+yi or x+yj text format, IMCOSH returns the #NUM! error value." Note this is #NUM!, not the #VALUE! that the logical-value clause on the same page specifies -- the two malformed-input branches are documented as returning DIFFERENT errors, which is why both are asserted. STORAGE-FORM GAP, and NOT a missing capability -- the distinction is the whole point of this case. IMCOSH is an Excel 2013 addition, so real Excel does not store it in a .xlsx under its plain name: Microsoft's XLSX-extensions future-function list (the reference this harness has used since batch A, mirrored in XlsxWriter's "Formulas added in Excel 2010 and later" table) gives the storage token as _xlfn.IMCOSH, alongside _xlfn.IMCOSH, _xlfn.IMCOT, _xlfn.IMCSC, _xlfn.IMCSCH, _xlfn.IMSEC, _xlfn.IMSECH, _xlfn.IMSINH and _xlfn.IMTAN. harness/xlfn_map.py therefore writes _xlfn.IMCOSH here, exactly as Excel would. EXECUTED RESULT: all four LibreOffice builds (24.2.0.3, 24.8.7.2, 25.2.0.3, 25.8.7.3) return #NAME? for that token. A five-spelling probe pins down what this is: _xlfn.IMCOSH, COM.MICROSOFT.IMCOSH, ORG.OPENOFFICE.IMCOSH and _xlfn.ORG.OPENOFFICE.IMCOSH are all #NAME? on every build, while the UNPREFIXED IMCOSH(...) evaluates on every build and returns exactly the string asserted here, byte for byte. So LibreOffice implements IMCOSH correctly, and its OOXML import simply has no mapping for the _xlfn.IMCOSH token Excel writes -- meaning a workbook saved by Excel that uses IMCOSH arrives in LibreOffice as #NAME? even though LibreOffice could compute it. This is the exact mirror image of batch B's COT/COTH/CSC/CSCH finding, where the _xlfn. token was the ONLY spelling LibreOffice accepted, and it is recorded here as its own divergence class rather than as an ordinary unsupported-function result.; MISMATCH vs expected: expected '#NUM!', got '#NAME?'
Executed test cases
Excel for the web (executed 2026-09-01 via OneDrive recalculation)
These values come from Excel for the web, not from desktop Excel. They are two different implementations of the calculation engine, and this run measured only the web one: the corpus was uploaded to OneDrive as .xlsx, recalculated by Excel for the web on open, and downloaded again for readback. Excel for the web is a rolling service with no pinnable version, so the run is identified by its date. Where a value here disagrees with the Expected column — which is Microsoft’s documentation of the desktop product — we cannot tell you whether the web engine diverges from the desktop one or the documentation is wrong about both, because we do not run desktop Excel.
| Formula | Description | Result | Expected | Verdict |
|---|---|---|---|---|
| =IMCOSH("4+3i") | Microsoft's documented worked example: the hyperbolic cosine of 4+3i | -27.0349456030742+3.85115333481178i | -27.0349456030742+3.85115333481178iProvenanceMicrosoft publishes '=IMCOSH("4+3i")' with the result -27.0349456030742+3.85115333481178i. Derived independently with mpmath at 40 digits from cosh(x+yi) = cosh(x)cos(y) + i*sinh(x)sin(y): cosh(4)cos(3) = -27.034945603074224648 and sinh(4)sin(3) = 3.8511533348117775366, then rendered through this corpus's own implementation of Excel's complex-string format, which reproduces the published string byte for byte. EXCEL'S COMPLEX-STRING FORMAT, which this corpus derives rather than assumes: a result is rendered as the real part, then the sign, then the imaginary coefficient followed by the suffix, with each part printed to at most 15 significant digits and trailing zeros stripped; a zero real part is omitted entirely, a zero imaginary part reduces the result to a bare real number, and an imaginary coefficient of exactly 1 or -1 prints as "i" / "-i" with no digit. That rule was not taken on faith -- it was written as a formatter in Python and validated against SEVEN independently published Microsoft strings in this batch alone (IMCOS, IMCOSH, IMCOT, IMCSC, IMCSCH, IMEXP and IMLN), which it reproduces byte for byte, before being used to predict any value this corpus asserts. String results are compared exactly, so a formatting-only difference (a trailing zero, "1i" for "i", a different digit count) fails the case and is recorded as its own divergence class, separate from a wrong numeric value. STORAGE-FORM GAP, and NOT a missing capability -- the distinction is the whole point of this case. IMCOSH is an Excel 2013 addition, so real Excel does not store it in a .xlsx under its plain name: Microsoft's XLSX-extensions future-function list (the reference this harness has used since batch A, mirrored in XlsxWriter's "Formulas added in Excel 2010 and later" table) gives the storage token as _xlfn.IMCOSH, alongside _xlfn.IMCOSH, _xlfn.IMCOT, _xlfn.IMCSC, _xlfn.IMCSCH, _xlfn.IMSEC, _xlfn.IMSECH, _xlfn.IMSINH and _xlfn.IMTAN. harness/xlfn_map.py therefore writes _xlfn.IMCOSH here, exactly as Excel would. EXECUTED RESULT: all four LibreOffice builds (24.2.0.3, 24.8.7.2, 25.2.0.3, 25.8.7.3) return #NAME? for that token. A five-spelling probe pins down what this is: _xlfn.IMCOSH, COM.MICROSOFT.IMCOSH, ORG.OPENOFFICE.IMCOSH and _xlfn.ORG.OPENOFFICE.IMCOSH are all #NAME? on every build, while the UNPREFIXED IMCOSH(...) evaluates on every build and returns exactly the string asserted here, byte for byte. So LibreOffice implements IMCOSH correctly, and its OOXML import simply has no mapping for the _xlfn.IMCOSH token Excel writes -- meaning a workbook saved by Excel that uses IMCOSH arrives in LibreOffice as #NAME? even though LibreOffice could compute it. This is the exact mirror image of batch B's COT/COTH/CSC/CSCH finding, where the _xlfn. token was the ONLY spelling LibreOffice accepted, and it is recorded here as its own divergence class rather than as an ordinary unsupported-function result. |
Matched |
| =IMCOSH(TRUE) | A logical argument, which the page rejects outright | #VALUE! | #VALUE!ProvenanceExcel documents: "If inumber is a logical value, IMCOSH returns the #VALUE! error value." A deliberate refusal to coerce -- TRUE becomes 1 in nearly every other numeric context. STORAGE-FORM GAP, and NOT a missing capability -- the distinction is the whole point of this case. IMCOSH is an Excel 2013 addition, so real Excel does not store it in a .xlsx under its plain name: Microsoft's XLSX-extensions future-function list (the reference this harness has used since batch A, mirrored in XlsxWriter's "Formulas added in Excel 2010 and later" table) gives the storage token as _xlfn.IMCOSH, alongside _xlfn.IMCOSH, _xlfn.IMCOT, _xlfn.IMCSC, _xlfn.IMCSCH, _xlfn.IMSEC, _xlfn.IMSECH, _xlfn.IMSINH and _xlfn.IMTAN. harness/xlfn_map.py therefore writes _xlfn.IMCOSH here, exactly as Excel would. EXECUTED RESULT: all four LibreOffice builds (24.2.0.3, 24.8.7.2, 25.2.0.3, 25.8.7.3) return #NAME? for that token. A five-spelling probe pins down what this is: _xlfn.IMCOSH, COM.MICROSOFT.IMCOSH, ORG.OPENOFFICE.IMCOSH and _xlfn.ORG.OPENOFFICE.IMCOSH are all #NAME? on every build, while the UNPREFIXED IMCOSH(...) evaluates on every build and returns exactly the string asserted here, byte for byte. So LibreOffice implements IMCOSH correctly, and its OOXML import simply has no mapping for the _xlfn.IMCOSH token Excel writes -- meaning a workbook saved by Excel that uses IMCOSH arrives in LibreOffice as #NAME? even though LibreOffice could compute it. This is the exact mirror image of batch B's COT/COTH/CSC/CSCH finding, where the _xlfn. token was the ONLY spelling LibreOffice accepted, and it is recorded here as its own divergence class rather than as an ordinary unsupported-function result. |
Matched |
| =IMCOSH("abc") | A string that is not in the documented complex-number format | #NUM! | #NUM!ProvenanceExcel documents: "If inumber is a value that is not in the x+yi or x+yj text format, IMCOSH returns the #NUM! error value." Note this is #NUM!, not the #VALUE! that the logical-value clause on the same page specifies -- the two malformed-input branches are documented as returning DIFFERENT errors, which is why both are asserted. STORAGE-FORM GAP, and NOT a missing capability -- the distinction is the whole point of this case. IMCOSH is an Excel 2013 addition, so real Excel does not store it in a .xlsx under its plain name: Microsoft's XLSX-extensions future-function list (the reference this harness has used since batch A, mirrored in XlsxWriter's "Formulas added in Excel 2010 and later" table) gives the storage token as _xlfn.IMCOSH, alongside _xlfn.IMCOSH, _xlfn.IMCOT, _xlfn.IMCSC, _xlfn.IMCSCH, _xlfn.IMSEC, _xlfn.IMSECH, _xlfn.IMSINH and _xlfn.IMTAN. harness/xlfn_map.py therefore writes _xlfn.IMCOSH here, exactly as Excel would. EXECUTED RESULT: all four LibreOffice builds (24.2.0.3, 24.8.7.2, 25.2.0.3, 25.8.7.3) return #NAME? for that token. A five-spelling probe pins down what this is: _xlfn.IMCOSH, COM.MICROSOFT.IMCOSH, ORG.OPENOFFICE.IMCOSH and _xlfn.ORG.OPENOFFICE.IMCOSH are all #NAME? on every build, while the UNPREFIXED IMCOSH(...) evaluates on every build and returns exactly the string asserted here, byte for byte. So LibreOffice implements IMCOSH correctly, and its OOXML import simply has no mapping for the _xlfn.IMCOSH token Excel writes -- meaning a workbook saved by Excel that uses IMCOSH arrives in LibreOffice as #NAME? even though LibreOffice could compute it. This is the exact mirror image of batch B's COT/COTH/CSC/CSCH finding, where the _xlfn. token was the ONLY spelling LibreOffice accepted, and it is recorded here as its own divergence class rather than as an ordinary unsupported-function result. |
Matched |
Google Sheets (executed 2026-08-31 via Drive import)
Google Sheets is a rolling service with no pinnable version, so this run is identified by its date. The corpus was imported to Drive as .xlsx, recalculated by Sheets, and exported back for readback.
| Formula | Description | Result | Expected | Verdict |
|---|---|---|---|---|
| =IMCOSH("4+3i") | Microsoft's documented worked example: the hyperbolic cosine of 4+3i | -27.0349456030742+3.85115333481178i | -27.0349456030742+3.85115333481178iProvenanceMicrosoft publishes '=IMCOSH("4+3i")' with the result -27.0349456030742+3.85115333481178i. Derived independently with mpmath at 40 digits from cosh(x+yi) = cosh(x)cos(y) + i*sinh(x)sin(y): cosh(4)cos(3) = -27.034945603074224648 and sinh(4)sin(3) = 3.8511533348117775366, then rendered through this corpus's own implementation of Excel's complex-string format, which reproduces the published string byte for byte. EXCEL'S COMPLEX-STRING FORMAT, which this corpus derives rather than assumes: a result is rendered as the real part, then the sign, then the imaginary coefficient followed by the suffix, with each part printed to at most 15 significant digits and trailing zeros stripped; a zero real part is omitted entirely, a zero imaginary part reduces the result to a bare real number, and an imaginary coefficient of exactly 1 or -1 prints as "i" / "-i" with no digit. That rule was not taken on faith -- it was written as a formatter in Python and validated against SEVEN independently published Microsoft strings in this batch alone (IMCOS, IMCOSH, IMCOT, IMCSC, IMCSCH, IMEXP and IMLN), which it reproduces byte for byte, before being used to predict any value this corpus asserts. String results are compared exactly, so a formatting-only difference (a trailing zero, "1i" for "i", a different digit count) fails the case and is recorded as its own divergence class, separate from a wrong numeric value. STORAGE-FORM GAP, and NOT a missing capability -- the distinction is the whole point of this case. IMCOSH is an Excel 2013 addition, so real Excel does not store it in a .xlsx under its plain name: Microsoft's XLSX-extensions future-function list (the reference this harness has used since batch A, mirrored in XlsxWriter's "Formulas added in Excel 2010 and later" table) gives the storage token as _xlfn.IMCOSH, alongside _xlfn.IMCOSH, _xlfn.IMCOT, _xlfn.IMCSC, _xlfn.IMCSCH, _xlfn.IMSEC, _xlfn.IMSECH, _xlfn.IMSINH and _xlfn.IMTAN. harness/xlfn_map.py therefore writes _xlfn.IMCOSH here, exactly as Excel would. EXECUTED RESULT: all four LibreOffice builds (24.2.0.3, 24.8.7.2, 25.2.0.3, 25.8.7.3) return #NAME? for that token. A five-spelling probe pins down what this is: _xlfn.IMCOSH, COM.MICROSOFT.IMCOSH, ORG.OPENOFFICE.IMCOSH and _xlfn.ORG.OPENOFFICE.IMCOSH are all #NAME? on every build, while the UNPREFIXED IMCOSH(...) evaluates on every build and returns exactly the string asserted here, byte for byte. So LibreOffice implements IMCOSH correctly, and its OOXML import simply has no mapping for the _xlfn.IMCOSH token Excel writes -- meaning a workbook saved by Excel that uses IMCOSH arrives in LibreOffice as #NAME? even though LibreOffice could compute it. This is the exact mirror image of batch B's COT/COTH/CSC/CSCH finding, where the _xlfn. token was the ONLY spelling LibreOffice accepted, and it is recorded here as its own divergence class rather than as an ordinary unsupported-function result. |
Matched |
| =IMCOSH(TRUE) | A logical argument, which the page rejects outright | #NUM! | #VALUE!ProvenanceExcel documents: "If inumber is a logical value, IMCOSH returns the #VALUE! error value." A deliberate refusal to coerce -- TRUE becomes 1 in nearly every other numeric context. STORAGE-FORM GAP, and NOT a missing capability -- the distinction is the whole point of this case. IMCOSH is an Excel 2013 addition, so real Excel does not store it in a .xlsx under its plain name: Microsoft's XLSX-extensions future-function list (the reference this harness has used since batch A, mirrored in XlsxWriter's "Formulas added in Excel 2010 and later" table) gives the storage token as _xlfn.IMCOSH, alongside _xlfn.IMCOSH, _xlfn.IMCOT, _xlfn.IMCSC, _xlfn.IMCSCH, _xlfn.IMSEC, _xlfn.IMSECH, _xlfn.IMSINH and _xlfn.IMTAN. harness/xlfn_map.py therefore writes _xlfn.IMCOSH here, exactly as Excel would. EXECUTED RESULT: all four LibreOffice builds (24.2.0.3, 24.8.7.2, 25.2.0.3, 25.8.7.3) return #NAME? for that token. A five-spelling probe pins down what this is: _xlfn.IMCOSH, COM.MICROSOFT.IMCOSH, ORG.OPENOFFICE.IMCOSH and _xlfn.ORG.OPENOFFICE.IMCOSH are all #NAME? on every build, while the UNPREFIXED IMCOSH(...) evaluates on every build and returns exactly the string asserted here, byte for byte. So LibreOffice implements IMCOSH correctly, and its OOXML import simply has no mapping for the _xlfn.IMCOSH token Excel writes -- meaning a workbook saved by Excel that uses IMCOSH arrives in LibreOffice as #NAME? even though LibreOffice could compute it. This is the exact mirror image of batch B's COT/COTH/CSC/CSCH finding, where the _xlfn. token was the ONLY spelling LibreOffice accepted, and it is recorded here as its own divergence class rather than as an ordinary unsupported-function result. |
Mismatch |
| =IMCOSH("abc") | A string that is not in the documented complex-number format | #NUM! | #NUM!ProvenanceExcel documents: "If inumber is a value that is not in the x+yi or x+yj text format, IMCOSH returns the #NUM! error value." Note this is #NUM!, not the #VALUE! that the logical-value clause on the same page specifies -- the two malformed-input branches are documented as returning DIFFERENT errors, which is why both are asserted. STORAGE-FORM GAP, and NOT a missing capability -- the distinction is the whole point of this case. IMCOSH is an Excel 2013 addition, so real Excel does not store it in a .xlsx under its plain name: Microsoft's XLSX-extensions future-function list (the reference this harness has used since batch A, mirrored in XlsxWriter's "Formulas added in Excel 2010 and later" table) gives the storage token as _xlfn.IMCOSH, alongside _xlfn.IMCOSH, _xlfn.IMCOT, _xlfn.IMCSC, _xlfn.IMCSCH, _xlfn.IMSEC, _xlfn.IMSECH, _xlfn.IMSINH and _xlfn.IMTAN. harness/xlfn_map.py therefore writes _xlfn.IMCOSH here, exactly as Excel would. EXECUTED RESULT: all four LibreOffice builds (24.2.0.3, 24.8.7.2, 25.2.0.3, 25.8.7.3) return #NAME? for that token. A five-spelling probe pins down what this is: _xlfn.IMCOSH, COM.MICROSOFT.IMCOSH, ORG.OPENOFFICE.IMCOSH and _xlfn.ORG.OPENOFFICE.IMCOSH are all #NAME? on every build, while the UNPREFIXED IMCOSH(...) evaluates on every build and returns exactly the string asserted here, byte for byte. So LibreOffice implements IMCOSH correctly, and its OOXML import simply has no mapping for the _xlfn.IMCOSH token Excel writes -- meaning a workbook saved by Excel that uses IMCOSH arrives in LibreOffice as #NAME? even though LibreOffice could compute it. This is the exact mirror image of batch B's COT/COTH/CSC/CSCH finding, where the _xlfn. token was the ONLY spelling LibreOffice accepted, and it is recorded here as its own divergence class rather than as an ordinary unsupported-function result. |
Matched |
LibreOffice Calc 25.8.7.3 (tested 2026-08-31)
| Formula | Description | Result | Expected | Verdict |
|---|---|---|---|---|
| =IMCOSH("4+3i") | Microsoft's documented worked example: the hyperbolic cosine of 4+3i | #NAME? | -27.0349456030742+3.85115333481178iProvenanceMicrosoft publishes '=IMCOSH("4+3i")' with the result -27.0349456030742+3.85115333481178i. Derived independently with mpmath at 40 digits from cosh(x+yi) = cosh(x)cos(y) + i*sinh(x)sin(y): cosh(4)cos(3) = -27.034945603074224648 and sinh(4)sin(3) = 3.8511533348117775366, then rendered through this corpus's own implementation of Excel's complex-string format, which reproduces the published string byte for byte. EXCEL'S COMPLEX-STRING FORMAT, which this corpus derives rather than assumes: a result is rendered as the real part, then the sign, then the imaginary coefficient followed by the suffix, with each part printed to at most 15 significant digits and trailing zeros stripped; a zero real part is omitted entirely, a zero imaginary part reduces the result to a bare real number, and an imaginary coefficient of exactly 1 or -1 prints as "i" / "-i" with no digit. That rule was not taken on faith -- it was written as a formatter in Python and validated against SEVEN independently published Microsoft strings in this batch alone (IMCOS, IMCOSH, IMCOT, IMCSC, IMCSCH, IMEXP and IMLN), which it reproduces byte for byte, before being used to predict any value this corpus asserts. String results are compared exactly, so a formatting-only difference (a trailing zero, "1i" for "i", a different digit count) fails the case and is recorded as its own divergence class, separate from a wrong numeric value. STORAGE-FORM GAP, and NOT a missing capability -- the distinction is the whole point of this case. IMCOSH is an Excel 2013 addition, so real Excel does not store it in a .xlsx under its plain name: Microsoft's XLSX-extensions future-function list (the reference this harness has used since batch A, mirrored in XlsxWriter's "Formulas added in Excel 2010 and later" table) gives the storage token as _xlfn.IMCOSH, alongside _xlfn.IMCOSH, _xlfn.IMCOT, _xlfn.IMCSC, _xlfn.IMCSCH, _xlfn.IMSEC, _xlfn.IMSECH, _xlfn.IMSINH and _xlfn.IMTAN. harness/xlfn_map.py therefore writes _xlfn.IMCOSH here, exactly as Excel would. EXECUTED RESULT: all four LibreOffice builds (24.2.0.3, 24.8.7.2, 25.2.0.3, 25.8.7.3) return #NAME? for that token. A five-spelling probe pins down what this is: _xlfn.IMCOSH, COM.MICROSOFT.IMCOSH, ORG.OPENOFFICE.IMCOSH and _xlfn.ORG.OPENOFFICE.IMCOSH are all #NAME? on every build, while the UNPREFIXED IMCOSH(...) evaluates on every build and returns exactly the string asserted here, byte for byte. So LibreOffice implements IMCOSH correctly, and its OOXML import simply has no mapping for the _xlfn.IMCOSH token Excel writes -- meaning a workbook saved by Excel that uses IMCOSH arrives in LibreOffice as #NAME? even though LibreOffice could compute it. This is the exact mirror image of batch B's COT/COTH/CSC/CSCH finding, where the _xlfn. token was the ONLY spelling LibreOffice accepted, and it is recorded here as its own divergence class rather than as an ordinary unsupported-function result. |
Mismatch |
| =IMCOSH(TRUE) | A logical argument, which the page rejects outright | #NAME? | #VALUE!ProvenanceExcel documents: "If inumber is a logical value, IMCOSH returns the #VALUE! error value." A deliberate refusal to coerce -- TRUE becomes 1 in nearly every other numeric context. STORAGE-FORM GAP, and NOT a missing capability -- the distinction is the whole point of this case. IMCOSH is an Excel 2013 addition, so real Excel does not store it in a .xlsx under its plain name: Microsoft's XLSX-extensions future-function list (the reference this harness has used since batch A, mirrored in XlsxWriter's "Formulas added in Excel 2010 and later" table) gives the storage token as _xlfn.IMCOSH, alongside _xlfn.IMCOSH, _xlfn.IMCOT, _xlfn.IMCSC, _xlfn.IMCSCH, _xlfn.IMSEC, _xlfn.IMSECH, _xlfn.IMSINH and _xlfn.IMTAN. harness/xlfn_map.py therefore writes _xlfn.IMCOSH here, exactly as Excel would. EXECUTED RESULT: all four LibreOffice builds (24.2.0.3, 24.8.7.2, 25.2.0.3, 25.8.7.3) return #NAME? for that token. A five-spelling probe pins down what this is: _xlfn.IMCOSH, COM.MICROSOFT.IMCOSH, ORG.OPENOFFICE.IMCOSH and _xlfn.ORG.OPENOFFICE.IMCOSH are all #NAME? on every build, while the UNPREFIXED IMCOSH(...) evaluates on every build and returns exactly the string asserted here, byte for byte. So LibreOffice implements IMCOSH correctly, and its OOXML import simply has no mapping for the _xlfn.IMCOSH token Excel writes -- meaning a workbook saved by Excel that uses IMCOSH arrives in LibreOffice as #NAME? even though LibreOffice could compute it. This is the exact mirror image of batch B's COT/COTH/CSC/CSCH finding, where the _xlfn. token was the ONLY spelling LibreOffice accepted, and it is recorded here as its own divergence class rather than as an ordinary unsupported-function result. |
Mismatch |
| =IMCOSH("abc") | A string that is not in the documented complex-number format | #NAME? | #NUM!ProvenanceExcel documents: "If inumber is a value that is not in the x+yi or x+yj text format, IMCOSH returns the #NUM! error value." Note this is #NUM!, not the #VALUE! that the logical-value clause on the same page specifies -- the two malformed-input branches are documented as returning DIFFERENT errors, which is why both are asserted. STORAGE-FORM GAP, and NOT a missing capability -- the distinction is the whole point of this case. IMCOSH is an Excel 2013 addition, so real Excel does not store it in a .xlsx under its plain name: Microsoft's XLSX-extensions future-function list (the reference this harness has used since batch A, mirrored in XlsxWriter's "Formulas added in Excel 2010 and later" table) gives the storage token as _xlfn.IMCOSH, alongside _xlfn.IMCOSH, _xlfn.IMCOT, _xlfn.IMCSC, _xlfn.IMCSCH, _xlfn.IMSEC, _xlfn.IMSECH, _xlfn.IMSINH and _xlfn.IMTAN. harness/xlfn_map.py therefore writes _xlfn.IMCOSH here, exactly as Excel would. EXECUTED RESULT: all four LibreOffice builds (24.2.0.3, 24.8.7.2, 25.2.0.3, 25.8.7.3) return #NAME? for that token. A five-spelling probe pins down what this is: _xlfn.IMCOSH, COM.MICROSOFT.IMCOSH, ORG.OPENOFFICE.IMCOSH and _xlfn.ORG.OPENOFFICE.IMCOSH are all #NAME? on every build, while the UNPREFIXED IMCOSH(...) evaluates on every build and returns exactly the string asserted here, byte for byte. So LibreOffice implements IMCOSH correctly, and its OOXML import simply has no mapping for the _xlfn.IMCOSH token Excel writes -- meaning a workbook saved by Excel that uses IMCOSH arrives in LibreOffice as #NAME? even though LibreOffice could compute it. This is the exact mirror image of batch B's COT/COTH/CSC/CSCH finding, where the _xlfn. token was the ONLY spelling LibreOffice accepted, and it is recorded here as its own divergence class rather than as an ordinary unsupported-function result. |
Mismatch |
Docs & syntax
- Excel (desktop): official documentation
- Google Sheets: official documentation
- LibreOffice Calc: official documentation
Where IMCOSH behaves differently
- Your function exists but your file cannot say so: _xlfn storage tokens
Executed: eight IM* functions LibreOffice implements return #NAME? on all four builds because it cannot read Excel's _xlfn. token for them, while COT and CSC only work under that same prefix. Eleven LibreOffice aliases are erased by its own exporter, and a token change between 24.2 and 24.8 makes a 24.8-written file open as #NAME? in 24.2.