Your code works fine, but it's missing half the roots, and a `Flatten`

ing of the list of numbers prior to applying `Re`

and `Im`

helps. Adding those in:

```
data = Flatten[
Table[{(-b + Sqrt[b^2 - 4 a c])/(2 a), (-b -
Sqrt[b^2 - 4 a c])/(2 a)}, {a, 1, 20}, {b, -20, 20}, {c, -20,
20}]];
ListPlot[{Re[#], Im[#]} & /@ data, PlotRange -> {{-3, 3}, {-3, 3}},
AspectRatio -> 1]
```

gets you this:

Which is pretty nice!

If you'd like to generate images more like the one in the Wiki article or my examples, you can do the following steps:

Generate a list of complex roots of polynomials of some order `N`

, where the vector of polynomial coefficients $\mathbf{v}=(a_0,\ldots,a_N)$ satisfies $|\mathbf{v}|\leq R$ for some cutoff radius $R$.

Convert each root into a 2d coordinate by taking the real and imaginary parts.

Create a sparse array, and increment the element at each root's coordinate by $\frac{1}{|\mathbf{v}|^2}$. That way, roots of simple polynomials (ie, polynomials whose coefficient vectors lie near the origin in $\mathbb{R}^{N+1}$) are "brightest", and roots of complicated polynomials (ie, polynomials whose coefficient vectors lie near the surface of the hypersphere) are dimmer. You'll need to translate, scale, and round the coordinates to be positive integers, as matrix indices must be positive integers.

Blur the sparse array. The raw sparse array isn't pretty, and blurring will reveal make it obvious which points are bright, and which are dim. Using the built-in `GaussianFilter`

is the quickest way, but it's not the best-looking. My preferred way is to FFT-convolve with a Lorentz-like distribution $\left(\frac{\gamma^2}{\gamma^2+x^2+y^2}\right)^\alpha$, where $\alpha$ determines the tail heaviness; $\alpha=1.15$ works pretty good.

Colorize the resulting array $M$ and render it using `Image`

. One easy way is to feed `Image`

the tensor-product $M\otimes\mathbf{c}$ where $\mathbf{c}$ is some 3-element RGB vector. In Mathematica 10, `TensorProduct`

preserves `PackedArray`

s, whereas in older versions it doesn't, so beware of RAM consumption if you're using an older version and want large images. Incidentally, that link has some examples of algebraic number plots.

Here's an example you can get from the above:

IIRC the green points are $N=3$ (cubics), and the yellow ones are $N=2$ (quadratics).

Similar with just quartics (I added additional red lighting for points near the origin):

And a large image of monic cubics where the linear coefficient is restricted to be an 8th root of unity:

https://www.flickr.com/photos/104348204@N05/11637086656/sizes/o/

## Example Code

Here's some code to do the above:

https://www.dropbox.com/s/ushalt5feb19wal/Root%20Generator.nb?dl=0
https://www.dropbox.com/s/wo4405fb73yrxgp/Root%20Visualizer.nb?dl=0

The "Root Generator" generates roots, converts them into a sparse array, and exports it to a file (steps 1-3). The "Root Visualizer" imports the files, and renders them (steps 4-5). It's got decent comments/instructions inside, but you may need to tweak the parameters to get what you want.

1

The techniques in this question might be useful.

– J. M.'s ennui – 2016-05-23T17:57:19.667Your link has the relevant subroutines in c++ code, but sadly the author left out a few required file: lset.c and rnd/frnd.c – M.R. – 2016-05-23T18:38:33.657

1

I've done similar algebraic number renderings before, see https://www.flickr.com/photos/104348204@N05/11637086656/sizes/o/ (very large image) and https://www.flickr.com/photos/104348204@N05/16570026460/sizes/o/ (moderately large image). The first image is cubics (with a special restriction on the linear coefficient) and the second is an image of the quartic roots. The typical recipe is to generate a large image array of zeros, lay down numbers at various points, blur the image, and colorize it.

– DumpsterDoofus – 2016-05-23T19:20:19.180Do you know what determines the size of these points in that picture? – Chip Hurst – 2016-05-24T15:01:39.720