Necro-addition:
Let's look at ##\frac{x}{1-y}, 0<|y|<1##. Then we know that since ##0<|y|<1##, then ##0<y^{k>1}<|y|<1##. Then if we multiply the numerator and denominator by ##1+y+y^{2}+...+y^{k-1}##, the numerator is now ##x(1+y+y^{2}+...+y^{k-1})## and the denominator is now ##1-y^{k}##.
So now since ##y^{k}## is smaller than ##y##, this means the denominator is closer to 1 so the numerator is closer to the original ##\frac{x}{1-y}##. Even better, this multiplies the digits of accuracy by k each time.
Converting this to an algorithm, we get:
##x_{0}=x, y_{0}=y##
##x_{n+1}=x_{n}(1+y_{n}+y_{n}^{2}+...+y_{n}^{k-1}), y_{n+1}=y_{n}^{k}##
There are optimizations for this, too. For example, if ##k=2^{n}##, then ##1+y+y^{2}+...+y^{k-1}=(1+y)(1+y^{2})(1+y^{4})...(1+y^{2^{n-1}})## and the code becomes something like:
x*=(1+y)
y*=y
x*=(1+y)
y*=y
...
x*=(1+y)
y*=y
For example, take k=8, then ##1+y+y^{2}+y^{3}+y^{4}+y^{5}+y^{6}+y^{7}=(1+y)(1+y^{2})(1+y^{4})##
But then, this is identical to n iterations where k=2. In fact, k=2 or any higher power of two by extension, provides the most optimal trade-off of multiplications for digits of accuracy.
For a real world application, suppose I want to get 9 digits (~30 bits) accuracy for ##\frac{x}{10}=\frac{x}{1.25}\frac{1}{8}##. Then ##y=-.25##, and because y is constant, we can precompute all of the powers of ##y##. Further, since ##y=-2^{-2}##, this will amount to simple bit-shifts. So the code is:
#x=379 integer only
x-=x>>2 #x=284.25 285
x+=x>>4 #302.015625 302
x+=x>>8 #303.195374 303
x+=x>>16 #303.2 303
x>>=3 #37.9 37 the final /8.