Many years ago, when designing a fixed-point CORDIC algorithm in hardware, I stumbled across a method of quantization by which you could "round" by truncating to the desired precision before adding a half. I haven't been able to find any references to this scheme when looking over the past few years and I'm not sure what it is called. I'll describe it in detail to see if someone recognizes it.
In comparison to the integer rounding method of Round-to-nearest with ties toward +∞, this would give the same error range (-.5, 0.5], but would round to nearest integer + a half rather than the nearest integer.
For example, consider the following numbers pre- and post-rounding:
$$ 0.0_{10} = 0.0_{2} \to 0_{2} + .1_{2} = 0.1_{2} = 0.5_{10} $$ $$ 0.25_{10} = 0.01_{2} \to 0_{2} + .1_{2} = 0.1_{2} = 0.5_{10} $$ $$ 0.5_{10} = 0.1_{2} \to 0_{2} + .1_{2} = 0.1_{2} = 0.5_{10} $$ $$ 0.75_{10} = 0.11_{2} \to 0_{2} + .1_{2} = 0.1_{2} = 0.5_{10} $$ $$ 1.0_{10} = 1.0_{2} \to 1_{2} + .1_{2} = 1.1_{2} = 1.5_{10} $$ $$ 1.25_{10} = 1.01_{2} \to 1_{2} + .1_{2} = 1.1_{2} = 1.5_{10} $$ $$ 1.5_{10} = 1.1_{2} \to 1_{2} + .1_{2} = 1.1_{2} = 1.5_{10} $$ $$ 1.75_{10} = 1.11_{2} \to 1_{2} + .1_{2} = 1.1_{2} = 1.5_{10} $$ $$ 2.0_{10} = 10.0_{2} \to 10_{2} + .1_{2} = 10.1_{2} = 2.5_{10} $$
In comparison, a method like Round-to-nearest with ties toward +∞ would instead add the $0.1_{2}$ first and then truncate. So the reason one may choose this alternate method of truncating first is that it avoids an addition computation, which could be costly depending on the context.
Note that the $0.1_{2}$ being added afterword is more of an implied addition, since there is no arithmetic required and the value need not be actually stored for a follow-up operation. The next operation (or LUT) would just need to be aware of the hardcoded 1 bit in its computation, which may or may not even involve extra computation depending on the context.