Experimenting with the "divisibility" of complex numbers, I stumbled across this thingy. It looks like a fractal. Although the formula does not do any iterations.
It reminds me of something. But I dont know what. Doing a Google image search brings up a couple of galaxies :) This image shows the region from (1/1) to (1/1). You can click it to see a 4000x4000 pixel rendering of it. Is this some known structure? Or some variation of another mathematical object that has a name? 
A zoom into the upper left region.

A deeper zoom.

UPDATE 1:The algorithm that creates this thing is:For each complex number c calculate the following: For all gaussian integers g like 1+1i, 2+2i, 3+3i... when calculating g/c which percentage results in a gaussian integer again? The higher the percentage, the lighter the pixel. UPDATE 24.10.2012:This post created a lot of response on Hacker News (and sparked a very interesting discussion), Twitter and various other websites as well as on the discussion section below. It was visited 30,000 times on the first day alone. Many very intelligent comments where made. Here are some reflections and updates: 
Is it a fractal?
Opinions seem to differ. There is some discussion about this question here. It seems there is no clear definition of "Fractal" to begin with. To make things simple, I will call this thing the "Complex Divisors Fractal". Or simply "CDF". 
Inversion seems to play a role.
Im not familiar with the concept of "inversion". But Google finds some pages that show images of inverted grids. And they have some similarity to the CDF. Sam at Fractal Forums suggested to create a version that uses multiplication instead of division to "uninvert" the CDF. On the left is the resulting image from (1/1) to (1/1). Indeed, the circles turn into straigth lines. Adam P. Goucher send me this link about Escher and inversion. 
Are the squares a result of rounding errors?
Several people theorized that the squares in the image could be artefacts caused by floating point limitations. And the answer is ... no! Some people implemented my algorithm and got the squares and some got no squares. Iazid had the idea that the squares could be the result of the type of "integer check". My original "intger check" was: if ((nMath.floor(n)) < 0.1) n is integer This is asymmetrical as it does see 1.05 as integer, but not 1.95. On the left is a rendering with a symmetrical version of the "integer check": if ((nMath.floor(n)) < 0.1) n is integer if ((nMath.floor(n)) > 0.9) n is integer else n is not an integer Voila! No squares. Unless otherwise noted, from here on all renderings are done with the new, symmetrical "integer check". 
The generalization
Iazid was the first who was brave enough to render the CDF by not only taking into account gaussian integers in the form of x+xi but all gaussian integers. This takes quadratically more time. However, I made some renderings. All following images are from the generalization. 
Here is a rendering of the area from 0.7/0.7 to 0.3/0.3

There are many parameters that can be played with and the result in very different images.
This is the same area, but with a smaller intervall that is counted as "integer". 
This one is using the old, asymmetrical integer check.

Another lovely rendering of the generalization. This one was done on the GPU.

Some other region of the generalization.
