Gaussian White Noise Wave Functions

Various examples of ulam spirals using a continuous tube to plot the points in conjunction with a white noise wave function to plot the z-coordinate. Generator written in Python using the VPython library.






Some other shapes using the gaussian white noise to determine dimensions of plot objects.

Spiral Video Series

Using smplayer/mencoder to convert PNG output to video. Formula and other control info is automatically inserted into the beginning of the video. This set is using a 2x2 pixel plotted out using the Ulam spiral "RULD" method. Pixel is black or red if the pixel number (pInt) passes the following test (e.g.): if round(((pInt)*pi)*pow(sqrt(pInt)/pi+(_multiplier/9), (1.2)) )%2==0: Iterating the value of _multiplier (or any other variable), we generate a new PNG file when the _range value is met. Stitching these images together into a video reveals motion within the overall pattern. For example, incrementing _multiplier very slightly for each image creates less disruption from one image to the next. Frame rate varies, generally within 2 to 15 FPS. Too bad blogger is overcompressing these, they are quite nice before they hit the FLV codec. C'est la vie.




Here's one of the first videos I cobbled together, a very quick prototype...

Random Grids

Detail:


I was bored today so I modified the base routine to select a cardinal direction randomly. These images are all built pulling from a list of 1,296 possible 2x2 pixel images. The original image is...

Marilyn Hex

Jaco Pastorius, Meet Stanislaw Ulam

These are all using a very simple test for n, round( pow(pInt,sqrt(1))/pi )%2==0

Enter Jeff Buckley

...and Jimi

Respliced Satellite Maps

Some tinkering with PIL and Google Maps produced these cartographic miscarriages:

And yes, we're still doing this with basic Ulam spiral algorithm.

Test: round( pow(sqrt(pInt)/e, 1.2) )%3==0


test: round( pow(sqrt(pInt)/e, 1.2) )%5==0


test: round( pInt/e )%3==0

Land-o-Lakes

Borrowing from Myka's number testing algorithm, I've introduced the x and y coordinates into the mix. The test round((pi*pX)*(pY)*pInt)%2==0
appears in Myka's Square series. Thanks for the math, mofo. Of course, the resulting imagery differs greatly. My functions seem to lack the additional voodoo required to create the interference patterns.





And then I studied the Myka algorithms a bit more carefully. Behold:

This is using round( (pi*pX)*(pY)*.0025) % 2==0, producing the same pattern as this Myka square.

But here we use 2500 unique 4x4 pixel images to iteratively construct the same pattern:


This is the core image that was used to create the above spiral:


This is not to say we simple overlay the image into the positive shape of the spiral. The core image is "ripped" into small square pieces, and a list of these images is referenced in as we step around the center point. The result is a color palette borrowed from the image.

Distilling the Lake Water

round( (pi*pX)*(pY)*(distillNumber(pInt)*.00025))%2==0


Pulling back on the stick we fly higher. This is at altitude .0000025 where round( (pi*pX)*(pY)*(distillNumber(pInt)*.0000025))%2==0



Higher:
round( (pi*pX)*(pY)*(distillNumber(pInt)*.00000025))%2==0


And yet higher still. Using .000000025 is absolutely rediculous, but it works.
round( (pi*pX)*(pY)*(distillNumber(pInt)*.000000025))%2==0

It appears to be a recursive fractal image, for the same pattern is re-emerging as we go deeper into the mathematical abyss.

A curious blend of pi and e...
round( ((pi*e)*pX)*(pY)*(distillNumber(pInt)* (sin(pInt)*.000000025) ))%2==0


round( (pX*pY)* pow(sqrt(pInt)/e, 1.2)*.0000025 )%3==0


Lord have mercy.
round( (pX*pY)* pow(sqrt(pInt)/e, 1.2)*.00000025 )%2==0


round( (pX*pY)* pow(sqrt(pInt)/e, 1.2)*.000000025 )%2==0


round( (pX*pY)* pow(sqrt(pInt)/e, 1.2)*.0000000125 )%2==0


round( (pX*pY)* pow(sqrt(pInt)/pi, 1.23)*.000000125 )%5==0

The Aboriginal Series

round( (pX*pY)* pow(sqrt(pInt)/pi, 1.23456789)*.000123456789 )%5==0


round( (pX*pY)* pow(sqrt(pInt)/pi, 1.23456789)*.0000123456789 )%5==0



round( (pX*pY)* pow(sqrt(pInt)/pi, 1.23456789)*.00005 )%3==0

Colorized version:


I'm pretty sure this overall pattern is a map of the universe, reality, and everything.

round( (pX*pY)* pow( sqrt(pInt), 1.23456789)*.00005 )%3==0

Image-Based Spiral Incantations

Exchange Building, Seattle, Washington.


The goldfinch was placed dynamically by the Python script. You can see that some of the tiles overlay the bird. The tiles are composed of a Letraset sheet for Helvetica and were dynamically ripped into 40 pixel squares before being rearranged using the Ulam algorithm.


This is basically a brand new alphabet for crazy people. Here you go. It is my gift to the world.




Feeling strange?


Strange chains...