that shows up when you print a special floating‑point value (like infinity
or NaN) with certain precisions; the classic strings 1.#INF (infinity) or 1.#IND
(indeterminate/NaN) get mangled to 1.#IO. In other words, if you see 1.#IO, your
number was almost certainly infinite or not‑a‑number, and the way it

[stackoverflow.com], [blog.csdn.net]

What it actually represents
On Windows, the C runtime historically prints special floating‑point
values like this:



such as 0.0/0.0, sqrt(-1), etc. [stackoverflow.com], [johndcook.com]

[stackoverflow.com]

When you format those with certain precisions (e.g., printf("%.3f", x) or
fixed/scientific iostream manipulators), the internal #INF / #IND text can be
truncated/rounded into #IO. Demonstrations of %.3f producing -1.#IO and of
iostream precision turning 1.#INF into 1.#IO are documented and reproducible.
[stackoverflow.com], [blog.csdn.net]

or NaN detected in your computation. [stackoverflow.com], [johndcook.com]

Typical causes (why you got it)
These usually create INF or NaN, which may print as #IO:

Division by zero (1.0/0.0 → +INF, -1.0/0.0 → -INF, 0.0/0.0 →
NaN). [johndcook.com]
Domain errors: sqrt(-1), log(-1), etc. → NaN. [johndcook.com]
Overflow to values too large for float/double → INF. [stackoverflow.com]
Formatting quirks with fixed precision or certain format specifiers (%.3f,
std::fixed << setprecision(3)), which turn #INF/#IND into #IO.
[stackoverflow.com], [blog.csdn.net]


How to detect and handle it correctly
Instead of relying on printed text, test the value:

C/C++ standard checks: std::isnan(x), std::isinf(x), std::fpclassify(x).
[en.cppreference.com]
MSVC‑specific: _isnan(x), _fpclass(x) (legacy). [learn.microsoft.com]

Example (C++):
C++#include <cmath>      // std::isnan, std::isinf, std::fpclassify#include
<iostream>void print_safe(double x) {       if (std::isnan(x))       std::cout
<< "NaN\n";    else if (std::isinf(x))  std::cout << (x > 0 ? "+INF\n" :
"-INF\n");    else                     std::cout << x << "\n";Show more lines
(Functions and behavior documented in the C/C++ libraries.)
[en.cppreference.com]

Practical tips (to avoid seeing 1.#IO)

Fix the math: guard against zero denominators and invalid domains; clamp inputs;
use safer formulations. (These are the root causes of INF/NaN.) [johndcook.com]
Change formatting: use %g or std::defaultfloat so special values print as

shown above. [en.cppreference.com]
Diagnose quickly: add checks after any risky operation (division, sqrt/log,




If you saw it in POV‑Ray output
POV‑Ray on Windows uses the same CRT for text formatting; if you emit
values (e.g., via #debug or write to a file) with fixed precision, 1.#IO can
appear when your scene math hits INF/NaN. The remedy is the same: guard your
calculations and test for isnan/isinf in any helper code before printing; or
change the format to avoid the mangled representation. (General CRT behavior and
formatting issues apply.) [en.cppreference.com], [stackoverflow.com]

- BE

Post a reply to this message