title: On the round half to even of the denormalized number to the smallest normal number in IEEE754
body: <p>This is a very simple question but needs an expert to answer.</p>
  
  <p>As we know, with subnormal in floating-point, we get rid off the gap between <code>2^emin</code> and <code>0</code>.</p>
  
  <p>By the round half to even (RTE) mode, we should round the infinite precision result as <code>(0.1111...1|r)*2^emin</code> or <code>(1.1111...1|r')*2^(emin-1)</code>? The number on the left of the point is the implicit bit.</p>
  
  <p><strong>For the first case:</strong>
  In the paper <em>What every computer scientist should know about floating-point arithmetic numerical computing</em>, in Figure2, I see the space on the left of <code>2^emin</code> is the same as the space on its right. So, straightforwardly, the numerical value of the left number is <code>2^emin - 2^(1-p)</code> (<code>p=24</code> in flp32). If we do RTE rounding, seems we should use the bit after 24bit significant as the rounding bit (i.e. <code>(0.111_1111_1111_1111_1111_1111|r)*2^emin</code>, see</p>
  
  <pre><code>--|---+---+....+-?-|---+---+....+---|-------+........
  --0---------------2^emin---------2^emin+1
  </code></pre>
  
  <p>I use a question mark (<code>?</code>) on the axis to represent the half point</p>
  
  <p><strong>For the second case:</strong> In the IEEE standard, for subnormal detection, before rounding it says "unbounded" exponent blabla. So if we can have unbounded exponent, we can shift the exact result to <code>(1.1111...1|r')*2^(emin-1)</code>. Under this case, we have the half-sized left space on <code>2^emin</code>. This is similar to all other adjacent spaces on <code>2^e</code>, but once closing to 0 on the axis, the number of spaces is infinite. See</p>
  
  <pre><code>--|...++++|-+-+-+...|---+---+....+-?-|-------+........
  --0-....----------2^emin-1----------2^emin
  ------| here is keep shrinking
  </code></pre>
  
  <p>In this case, seems we should round the exact result as</p>
  
  <pre><code>(1.111_1111_1111_1111_1111_1111|r')*2^(emin-1)
  </code></pre>
  
  <p>By 1-bit-left shifting the case 1 result, means guard bit is useful in this case.</p>
  
  <p>In these two cases, we have different rounding bit, so may get different results.
  Which case we should follow?
  I couldn't see any document/paper talks about this topic clearly.</p>