# Category Archives: functions

## Proxy - (object always defined)

This uses a proxy to make sure all keys/props of an object are always defined.

```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 let spec = { get: (o, key) => { return o[key] != null ? o[key] : o[key] = O(); }, set: (o, key, v) => { o[key] = v; } };   let O = () => { return new Proxy({}, spec); };   let dynamic = O(); dynamic.prop.creation = 'is interesting'; dynamic.prop.stuff.not.clear.what.this.could.be.used.for = 123;   // log out full structure let f = (o) => { for (let i in o) { console.log(o[i]); if (typeof o[i] === 'object') f(o[i]); } }; f(dynamic);```

Outputs:

```Proxy {creation: "is interesting", stuff: Proxy}
is interesting
Proxy {not: Proxy}
Proxy {clear: Proxy}
Proxy {what: Proxy}
Proxy {this: Proxy}
Proxy {could: Proxy}
Proxy {be: Proxy}
Proxy {used: Proxy}
Proxy {for: 123}
123
```

## 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

Also posted in Graphics, Math, graphics algorithms, javascript, misc, motion | Tagged , , | Leave a comment

## Recursion Form

Actionscript:
1. x = y = 10
2. graphics.lineStyle(1,0);
3. drawBox(6);
4.
5. function drawBox(iter:Number=10, count:Number=1, y:Number=0, w:Number=500):void{
6.        if (count <iter){
7.                var width:Number = w / count
8.                for (var i:int = 0; i<count; i++){
9.                    graphics.drawRect(i * width, width * count/w, width, width);
10.                }
11.                count++;
12.                drawBox(iter, count, y, width);
13.        }
14. }

This small snippet just draws this image:

If you have an idea for a short recursive snippet. Feel free to post it in the comments.

Also posted in Graphics | Tagged , , | 6 Comments

Actionscript:
1. initOperators();
2.
3. trace(zipWith("-", [1,2,3], [1,2,3]));
4. trace(zipWith("+", [1,2,3], [1,2,3]));
5. trace(zipWith("*", [1,2,3], [1,2,3]));
6. trace(zipWith("+", [1,1,1,3], [4,5,6,7]));
7. trace(zipWith("<<", [2, 4], [1,1]));
8. /*
9. outputs:
10.
11. 0,0,0
12. 2,4,6
13. 1,4,9
14. 5,6,7,10
15. 4,8
16. */
17.
18. function zipWith(op:String, a:Array, b:Array):Array{
19.     var aLeng:int = a.length;
20.     var bLeng:int = b.length;
21.     var leng:Number = (aLeng <bLeng) ? aLeng : bLeng;
22.     var zipped:Array = [];
23.
24.     if (!this[op])return [];
25.
26.     for (var i:int = 0; i<leng; i++){
27.         zipped[i]=this[op](a[i], b[i]);
28.     }
29.     return zipped;
30. }
31.
32. function initOperators():void{
33.     this["+"]=function(a:Number, b:Number):Number{ return a + b };
34.     this["-"]=function(a:Number, b:Number):Number{ return a - b };
35.     this["/"]=function(a:Number, b:Number):Number{ return a / b };
36.     this["*"]=function(a:Number, b:Number):Number{ return a * b };
37.     this["%"]=function(a:Number, b:Number):Number{ return a % b };
38.
39.     this["&"]=function(a:Number, b:Number):Number{ return a & b };
40.     this["<<"]=function(a:Number, b:Number):Number{ return a <<b };
41.     this["|"]=function(a:Number, b:Number):Number{ return a | b };
42.     this[">>"]=function(a:Number, b:Number):Number{ return a>> b };
43.     this[">>>"]=function(a:Number, b:Number):Number{ return a>>> b };
44.     this["^"]=function(a:Number, b:Number):Number{ return a ^ b };
45. }

This snippet is basically like the haskell zipWith() function. It can combines two arrays into one array given a single function. In this case I defined a bunch of operator functions, but it would work with any kind of function that takes two arguments and returns a value. You could extend this to work with strings and do other strange things I guess.

If you have yet to go play with haskell ... go do it now.

Also posted in Number, Operators, arrays, binary, misc, return values | Tagged , , , | 2 Comments