Hypothetical question on floating point normalization
So first off, the implicit digit to the left of the radix point is not called an "integral". That's a very confusing use of that word. But I digress.

Having an unnormalised representation for floating-point numbers may simplify the final step of any basic floating point operation, because you don't need to re-normalise the result. But in turn, the initial steps of just about every floating point operation become more complex.

Let's take division as an example. Most modern floating-point hardware use Goldschmidt's algorithm, which is based on this idea:

Suppose that we want to calculate $\frac{n}{d}$, where $d$ is close to (but not equal to) one. Then we multiply both the numerator and the denominator by $2-d$.

Suppose $d = 1 + \epsilon$, then the new division problem is:

$$\frac{n}{1+\epsilon} = \frac{n(2-d)}{(1+\epsilon)(1-\epsilon)} = \frac{n(2-d)}{1-\epsilon^2}$$

This results in a denominator which is quadratically closer to 1. Repeat this operation until it gets close enough.

So Goldschmidt's algorithm works as follows. To calculate the quotient of two floating point numbers:

$$\frac{m_1 \times 2^{e_1}}{m_2 \times 2^{e_2}}$$

where $m_1$ and $m_2$ are between 1 and 2, we use a lookup table to find an approximation to $\frac{1}{m_2}$, which we will call $R$. Then we calculate:

$$n_1 = m_1 R$$
$$d_1 = m_2 R$$
$$n_{i+1} = n_i (2-d_i)$$
$$d_{i+1} = d_i (2-d_i)$$

and when we have done enough iterations (say $j$), we return:

$$n_j \times 2^{e_1 - e_2}$$

The final step will involve normalisation; $n_j$ will not, in general, be between 1 and 2. So if we could have unnormalised floating point numbers, the final step will be a bit simpler.

But in return, the table lookup operation will be more complex. With normalised numbers, you can just use the first few bits of the significand. ("Significand", incidentally, refers to the part of the mantissa that is actually stored in a normal floating-point number, without the implicit leading 1.)

So in that sense, there is no advantage to having an unnormalised representation for floating-point numbers. What you gain in a simpler final step you lose by having more complex initial steps.