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.

## 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 "un-invert" 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 ((n-Math.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 ((n-Math.floor(n)) < 0.1) n is integer

if ((n-Math.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".

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