Relative merits of fixed point vs floating point computation? I have a digital signal processing system that operates on a fast x86 machine using double precision floating point numbers.
It occurred to me that I am not really using the huge dynamic range of the floating point representation -- all quantities fit easily in the range ±32768.

My question: is it possible that switching to fixed point computations would provide a benefit in numerical accuracy (high priority) or computation time (low priority)?

Of course, the answer depends on how many bits are available for a fixed-point calculation.  How many bits of precision do typical fixed-point systems utilize?  Is it possible to efficiently do fixed-point calculations, with, say, 64 bits (16 bits integer part, 48 bits fractional part) on x86-64?  

I had always thought that fixed-point calculations were used only in situations where CPU power is limited--does it make sense to use fixed-point calculations when CPU power is no concern?
The numerical accuracy of integers will only be better than the numerical accuracy of floats if the integer resolution is better.  Doubles have 52 fractional bits, so double-precision floats have a resolution worse than integers at around $2^{52}$, which is much larger than 32768 ($2^{15}$).  So, no, the numerical accuracy will not be better if you go to integers.

The second issue is speed.  The answer is: it depends on the hardware.  If you are running your program on a digital signal processor that has multiple fixed point multiply/accumulate cores then yes, it will be far faster in fixed point.  On an x86 chip, on the other hand, it will actually probably be slower in fixed point.  I did exactly what you are talking about once and saw my execution times increase.

After doing some searches on the internet I found out that that is common.  The reason is because it has a dedicated floating-point processor that isn't doing anything when you transition to fixed point, while the fixed-point hardware is shared with the regular fixed-point action, such as pointer arithmetic.

If you want to speed up the processing, the way to do it is to change from double-precision floats to single-precision floats.  That should produce a significant increase in speed.  That would, of course, reduce your numerical accuracy though.