Monthly Archives: July 2018

Hermit Crab Curve as PRNG (a deterministic pseudo-random number generator with contrast and smoothness - inspired by stochastic and organic randomness)

Around 2015 I had the idea for a PRNG that would clamp itself and have moments of “smoothness”. When I got around to trying to create such a thing, the result was something I jokingly called the “Hermit Crab Curve”. I also called it the “Shard Curve”.

The equation for the curve defines a radius in polar coordinates:

Where a and d are paramters that control the detail of the curve. o is a rotation and offset value for the angle and s is a scalar. Note the use of rem. The resulting curve is much less interesting if a standard modulo is used in place of a remainder:

The above variable values were found using this interactive version of the equation:

To illustrate how you might use this as a PRNG I created this fork of the above pen:

That, in combination with the information from my other article from yesterday… Should be enough to see what I mean.

You can read the original description of the Hermit Crab Curve that I created using ArcType here:

If you end up using this for something interesting let me know. I’d love to see it

Posted in Graphics, Math, functions, graphics algorithms, javascript, misc, motion | Tagged , , | Leave a comment

PRNG Sine Rendering (Easiest Seeded Random with Index)

Here is a codepen showing seeded random numbers created use `Math.sin`. We’ll get to the code in a bit, first a little backstory…

Over the years I’ve used all manner of famous random number generators. From Tausworthe to Mersenne Twister.

Sometime last year I was trying to find a seeded PRNG, when working in Objective-C `arc4random` seems to be the common choice. I quickly became frustrated however as it didn’t seem possible or at least didn’t seem easy at all to reset the sequence of numbers. Maybe there’s an easy way, but whatever it is, I couldn’t find it. So after probably an hour of frustration trying all the weird different PRNGs, I decided to resort to a super simple old trick.

Why do you care about resetting the sequence?

Having a seed that you save at the beginning of your program can be super powerful. You can use anything for this seed, like the time or just another random number. From that point on your random numbers will be completely deterministic and depending on the complexity of your program you can simply save the seed and use it again later - causing your program to do exactly the same thing it did last time it had that seed. Those of you who dabble with generative artwork are probably familiar with this idea.

This experiment uses that trick:

Those textures will always be the same when the seed is 18. Thats an old experiment from the flash days, I think I used Grant Skinner’s seeded PRNG for that.

On the off chance you still have flash in your browser you can see it here:

Static black and white:
http://zevanrosser.com/sketchbook/things/bw_tex_static.html

Animated black and white:
http://zevanrosser.com/sketchbook/things/bw_tex_animated.html

Ugly colors version:
http://zevanrosser.com/sketchbook/things/col_tex_animated.html

It turns out that if you take sine or cosine and pop very large values for theta into it - you get something that looks very random. Lets look at the code:

```1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 var rc = 0, seed = 30, MAX_RAND = 0xffffff;   function idxRand(nth) { if (nth != null) rc = nth; rc++; return Math.abs(Math.sin(seed * rc) * MAX_RAND); }   var firstFour = [idxRand(), idxRand(), idxRand(), idxRand()], second = idxRand(1), fourth = idxRand(3);   console.log(firstFour); console.log(second); console.log(fourth);   var canvas = document.createElement("canvas"), c = canvas.getContext("2d");   canvas.width = 400; canvas.height = 300; c.fillStyle = "black"; c.fillRect(0, 0, canvas.width, canvas.height); document.body.appendChild(canvas);   for (var i = 0; i < 300; i++) { c.fillStyle = "red"; c.fillRect(idxRand() % 200, i, 4, 4);   c.fillStyle = "green"; c.fillRect(200 + Math.random() * 200, i, 4, 4); }```

Will output something like this:

```[16576418.984205123, 5113873.3245154265, 14998774.234509233, 9741038.668934602] 5113873.3245154265 9741038.668934602```

This code could be improved in a few different ways - but its good enough to illustrate the technique. Lines 1-9 are all you need to have a reproducible random sequence. With a large step value for theta and an even larger coefficient (0xffffff) for sine, you can use modulo to get the range you need (line 30). You can access the old values by passing an index to `idxRand`. This is illustrated in lines 11 through 17 - where we get the first four values and then grab them again using the index argument.

While significantly statistically different - and likely significantly different performance-wise, you’ll notice that visually there is little difference…

UPDATE: Had an idea that an alternative post title for this would be Easily Attain the Nth value from a PPRNG(pseudo-pseudo-random-number-generator)…

Emmet as a Template (aka zen-coding)

This is not the most useful thing in the world - was just an idea I had awhile back… First off, I love Emmet (formerly zen-coding) created by Sergey Chikuyonok. I especially like it for quickly writing html or jsx.

While I don’t use them that often, I really enjoy Jade and Pug. Anyway, I realized you could do similar things with Emmet with just a few little tweaks… So created this codepen:

As you can see - with a few regular expressions you can use Emmet _sort of_ like Jade. Definitely just an experiment, but interesting nevertheless.

The Experimental Zeta Project

Sometime in 2015 I decided to do an experiment. I created a speed coded graphics library with the intention of eventually completely re-writing it . The idea being, I would work on an elegant (albeit strange) graphics library that would make it easy to quickly create complex graphics with very little code. The result was Zeta… which can do things like this:

or…

or even…

that…

There is more than meets the eye here. Here is a list of some things that may not be immediately apparent:

1. While this is all done with canvas, everything is percentage based so it can scale in realtime to an arbitrary size. Like this (all of the above examples do the same).
2. It uses coffeescript to so that the syntax is extra minimal.
3. It defines shapes as polar and parametric functions, so you can easily create spirals and waves and really any kind of parametric curve you want.
4. the data of the curves can be separated from the default rendering, and you can use normal canvas command to interpret the data.
5. The actually library code is a real speed coded mess that could easily be replaced with decent code, leaving the existing API intact.
6. Its very easy to create pseudo-responsive grids and animations.
7. etc…

Here are the unfinished docs, basically just a list of functions and properties: Zeta Docs

Obviously I never got around to the re-write phase, but I still may revisit Zeta at some point. I have many many more things that I created with Zeta… Maybe I’ll write about some of them in the future.

There’s enough here for people to play around with, and if you feel like seeing some strange code. Have a look at one of the later versions of the lib itself: (brace yourself)

it may be obvious that some of the ideas in this lib are ever so vaguely inspired by processing