Implementation of CIC filter using floating point
Heh.  I've just worked this out, and I think you can implement a CIC using floating point -- but it wouldn't be perfect, and in most processing environments it would be a waste of resources.
The basic CIC stage is an integrator implemented modulo a maximum number -- in an integer implementation, this would be $x_{max} = 2^n$ where $n$ is the word length, in a non-integer fixed-point implementation it would be the maximum span of values that the data type could hold.
$$x_k = \left(x_{k-1} + u_k \right) \mod x_{max} \\ 
y_k = \left(x_k - x_{k - N} \right) \mod x_{max}$$
where &quot;$y = x \mod x_{max}$&quot; maps $x$ onto the interval $y \in \left[ -\frac{x_{max}}{2}, \frac{x_{max}}{2} \right )$.
You choose $x_{max}$ so that over $N$ samples, there's no chance that the value of $x_k$ can roll over more than once.
The thing that makes the CIC less than practical in a floating point environment is that you have to do the modulo operation explicitly, either by actually doing a floating point modulo, or by detecting that $x_k$ or $y_k$ is outside of $\left[ -\frac{x_{max}}{2}, \frac{x_{max}}{2} \right )$ and adjusting them by adding or subtracting $x_{max}$.
The thing that makes the CIC less than exact in a floating point operation is that floating point arithmetic truncates more or less depending on the exponent.
The reason that the CIC is so attractive for fast, computationally efficient DSP is because with fixed point (integer or not) math, is because with typical adder hardware and 2's part arithmetic, the modulo operation comes for free -- it's just the fixed-word-width overflow that's usually the bane of fixed-point arithmetic.  So you pay nothing -- in a sense, less than nothing* -- for the modulo.
The reason that CIC is exact is because if all the arguments are fixed point with the same radix (i.e., integers), then all of the operations are bit-exact.  This can't be said for floating point.
So -- in a floating point environment you can implement a CIC filter.  But, you'll be larding on so much extra computational resources to do the two modulo operations, that you may as well do something else, like half-band filters.  The only place where it would make sense to use a CIC in floating point, in my opinion, would be if you're working on a test bench and you want to simulate a system that you're going to implement later.
* because you don't have to worry about detecting it, or preventing it.