As we know, machine epsilon limits relative rounding error in the range of normalized floating point numbers. But it is easy to check that this is not true for denormalized  numbers. My question is when one should take this subtlety into account and what sort of problems can this issue cause? Any references?
Machine epsilon does not limit relative rounding error for denormals. Is this a problem?
reference request;floating point
Back in the era of Intel 387 math coprocessors I had to maintain an interrupt handler for floating point exceptions.  Apart from that, I agree that pretty much everyone ignores denormals (or subnormals as they are sometimes called), and this is successful in part because the IEEE 754 standard default handling of gradual underflow hides their (presumably rare) occurrance (better, at least, than overflow exceptions).Denormals are an edge case of loss of significance, from exponent underflow.  As a matter of theoretical treatment in numerical methods, it is most likely to arise by subtractive cancellation.  But we will often have subtractive cancellation (whether benign or harmful) without creating denormals.Some studies have been done on the slower performance caused by operations on denormals, such as Dooley and Kale (2013), Quantifying the Interference Caused by Subnormal Floating-point Values, and by the same authors with additional coauthors, Performance Degradation in the Presence of Subnormal Floating-Point Values.Here's a blog article from 2012 that links back to a highly upvoted StackOverflow thread on the performance hit from denormalized floats.Quantifying the effects on numerical accuracy are apt to be specific to the application, and in many cases the luxury of doing a comparison with multiple or arbitrary precision arithmetic may be the only way of getting a definitive measure.