Depth buffer value equation problem

The value stored in the depth buffer is post-projection Z divided by post-projection W. So to get the formula for computing that value you should look at how your projection matrix is constructed. A typical, symmetrical perspective projection constructed for D3D conventions will look like this:

xScale     0          0               0
0        yScale       0               0
0          0       zf/(zf-zn)         1
0          0       -zn*zf/(zf-zn)     0

So, let's assume you start with a position in view-space that looks like this: (Xv, Yv, Zv, 1). You'll then transform by your projection matrix to get (Xp, Yp, Zp, Wp). This gives us the following:

Zp = (Zv * zf)/(zf - zn) + 1.0 * -zn * zf/(zf - zn)
Wp = Zv

If we say that a = zf/(zf - zn) and b = -zn*zf/(zf-zn), then Zp / Wp = ((Zv * a) + b) / Zv = a + b / Zv. So really a and b are just the last two values from the third column of your projection matrix. Note that for D3D conventions a and b are different than what you get from that article, which accounts for the differences in clip space between D3D and OpenGL. It's also different if you use an orthographic projection instead of a perspective projection.

To answer your second question, a floating point depth buffer stores the same Zp / Zw value as an integer depth buffer. It just doesn't do the "multiply by (1 << N)" part, because it stores the value directly as a float instead of converting to a normalized integer format.