Without the rest of the question, if I just saw the phrase "bitcast naively to float", I might assume it meant changing none of the bits, but simply changing the type from unsigned integer to floating point.

For example, using 32 bit unsigned ints and 32 bit floats:

The unsigned integer 1234567 is 100101101011010000111 in binary, which is also the binary representation of the 32 bit float 0.000000000000000000000000000000000000001729997.

This would give you a float for every possible int, but this would include all the floats, including negative zero, positive and negative infinities, and NaN and the subnormal numbers, which you'd prefer to avoid.

Wikipedia has a description of how the type is laid out: https://en.wikipedia.org/wiki/IEEE_754

Yes, that's what I mean, specifically this. I found out through trial and error that a simple bitcast isn't enough.

If trial and error gave you results that did not suit your purpose, describing what was unsuitable would help narrow down what you need.

The output was nowhere near uniform IIRC. I don't quite understand what's ambiguous about what I need. Uniform floating point is pretty standard in linalg computing.

If you were just asking for a uniformly random float in a range, I don't think there would be any doubt over what you mean.

I'm only asking for clarification because you're trying to convert from uniform integers to uniform floats. With uniform integers, each possible value has the same probability of occurring. With floats, being uniform by necessity means a larger value has a higher probability of occurring. If that's what you want, then some of the integers will need to map to the same float in order to maintain uniformity.

I wanted to clarify your requirements because mapping each integer to a different float will not give a uniform distribution over floats, because floats themselves are not uniformly distributed over their range.

If you need to map multiple integers to the same float, that's fine, as long as the output is uniform. I've allowed answers between bounds in case that's useful, but given the bounds could be +-floatmax, I see little difference

In a small range you can make the choice of float uniform by mapping each integer to the same float as several other integers to balance out the uneven distribution of floats. However, in the full range [-floatmax, floatmax] there are as many floats as integers, so you cannot take that approach unless you start with a larger size integer type (such as mapping 64 bit integers to 32 bit floats).

Mapping 32 bit integers to 32 bit floats, there cannot exist a mapping that is uniform and covers all floats.