# Category Archives: Math

## OVM Pseudo-Algebra and Surreal Numbers

Was just watching this funny video on Numberphile:

Here is the Surreal Numbers book on archive.org:

https://archive.org/stream/SurrealNumbers/Knuth-SurrealNumbers#page/n7

Got a kick out of the story around this stuff… When Knuth shows the notation for surreal numbers I suddenly remembered a weird program I’d written awhile back.

## OVM

I had been out drawing in my sketchbook one sunday (almost 2 years ago) and found myself creating a tiny little system of symbols:

A few days later I speed coded a version of the system. Apparently I had posted a screenshot on FB while I was working on it:

See if you can figure out how it works. I’m sure the code could be cleaned up a bit…

While OVM has little/nothing to do with Surreal Numbers - I’m glad the video reminded me it…

In 2015 I created QuickShader… which just takes the boilerplate out of showing a shader in the browser. Here are a few examples:

Also posted in Graphics, color, glsl, graphics algorithms, html5, javascript, motion, pixel manipulation | Tagged , | Leave a comment

Being able to draw smooth lines that connect arbitrary points is something that I find myself needing very frequently. This is a port of an old snippet that does just that. By averaging control points of a quadratic bezier curve we ensure that our resulting Bezier curves are always smooth.

The key can be seen here with the `bezierSkin` function. It draws either a closed or open curve.

```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 35 36 37 38 // array of xy coords, closed boolean function bezierSkin(bez, closed = true) { var avg = calcAvgs(bez), leng = bez.length, i, n;   if (closed) { c.moveTo(avg[0], avg[1]); for (i = 2; i < leng; i += 2) { n = i + 1; c.quadraticCurveTo(bez[i], bez[n], avg[i], avg[n]); } c.quadraticCurveTo(bez[0], bez[1], avg[0], avg[1]); } else { c.moveTo(bez[0], bez[1]); c.lineTo(avg[0], avg[1]); for (i = 2; i < leng - 2; i += 2) { n = i + 1; c.quadraticCurveTo(bez[i], bez[n], avg[i], avg[n]); } c.lineTo(bez[leng - 2], bez[leng - 1]); } }     // create anchor points by averaging the control points function calcAvgs(p) { var avg = [], leng = p.length, prev; for (var i = 2; i < leng; i++) { prev = i - 2; avg.push((p[prev] + p[i]) / 2); } // close avg.push((p[0] + p[leng - 2]) / 2); avg.push((p[1] + p[leng - 1]) / 2); return avg; }```

The control points are then averaged to ensure that the curve contains no sharp angles.

Also posted in Graphics, arrays, bezier, graphics algorithms, html5, javascript | Tagged , , , , | Leave a comment

Awhile back I thought it would be interesting to add some quick fake lighting to a personal project of mine - that for lack of a better description is a windows management system.

Here is a screenshot of the windows management system with lighting turned on:

Here is a video of me using the system:

I whipped up this prototype (don’t mind the jQuery)

There are really two keys that make this work. Getting the shadow in place and adjusting the gradient. All we really need is the angle and distance from a given `div` in relation to the “light”:

```1 2 3 4 5 6 7 8 9 10 11 12 13 let calcAng = function(x, y) { let lightPos = light.position() let dx = lightPos.left - x; let dy = lightPos.top - y; return -Math.atan2(dy, dx) / Math.PI * 180; };   let calcDist = function(x, y) { let lightPos = light.position() let dx = lightPos.left - x; let dy = lightPos.top - y; return Math.sqrt(dx * dx, dy * dy); };```

Standard `atan2` and the pythagorean theorem get us this. Once we have those - we can use them to set our gradient and shadow values:

```1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 // warning (apparently this function is slightly speed coded) let calcShade = function(x, y) { let angle = calcAng(x, y); let dist = calcDist(x, y); let sx = dist * Math.cos(-angle * Math.PI / 180) * -1; let sy = dist * Math.sin(-angle * Math.PI / 180) * -1;   sx = Math.min(20, Math.max(sx, -20)); sy = Math.min(20, Math.max(sy, -20)); let blur = Math.min(100, dist); let hBlur = Math.min(50, blur) * 0.5; // consider distance in the eq? return { bg: `-webkit-linear-gradient(\${angle}deg, rgba(0, 0, 0, 0.2), rgba(255, 255, 255, 0.4) \${blur}%)`, shadow: `\${sx}px \${sy}px \${hBlur}px rgba(0, 0, 0, 0.15)` }; };```

There are more videos of the windows management system on my youtube channel. Here’s another from a much earlier version of the system.

Maybe I’ll post more about that in the future…

## Quick line in HTML and JavaScript

Usually if you want to draw lines in HTML you use canvas or SVG. Awhile back I wondered how I might do it without those. This is really just a proof of concept speed coded answer to that question:

This works by using a div with a border, rotating it and scaling it as needed so it fits between two arbitrary points.

This could be abstracted a bit more, but it works pretty well. I usually choose `setInterval` over `requestAnimationFrame` when prototyping - because I like to easily be able to change the speed of
framebased things like this. If I were to try and make this code more dynamic, I would probably switch out to `requestAnimationFrame`.

If you try and connect two lines together - you’ll notice some inaccuracy - a good argument for using SVG or canvas over something like this. That said, if you are connecting two elements using a single line, this inaccuracy would become irrelevant.

## 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, 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)…

## Gumowski/Mira Pseudo-Soundwave

Actionscript:
1. [SWF(width = 600, height = 600)]
2. var a:Number = 0.02;
3. var b:Number = .9998;
4.
5. var xn1:Number = 5;
6. var yn1:Number = 0;
7. var xn:Number, yn:Number;
8.
9. var scale:Number = 10;
10. var iterations:Number = 20000;
11. var step:Number = stage.stageWidth / iterations;
12.
13. function f(x:Number):Number{
14.     var x2:Number = x * x;
15.     return a * x + (2 * (1 - a) * x2) / (1 + x2);
16. }
17.
18. var canvas:BitmapData = Bitmap(addChild(new Bitmap(new BitmapData(600,600,false,0xEFEFEF)))).bitmapData;
19.
20. var circle = new Sprite();
21. with(circle.graphics) beginFill(0, 0.3), drawCircle(2,2,1);
22.
23. var dot:BitmapData = new BitmapData(4,4,true, 0x00000000);
24. dot.draw(circle);
25.
26. var pnt:Point = new Point();
27.
28. var txt:TextField = TextField(addChild(new TextField()));
29. txt.text = "move mouse";
30.
32. function onLoop(evt:Event):void {
33.
34.     canvas.fillRect(canvas.rect, 0xEFEFEF);
35.
36.     a = mouseY / 1000;
37.     xn1 = mouseX / 30;
38.     yn1 = 0;
39.     for (var i:int = 0; i<iterations; i++){
40.           xn = xn1;
41.           yn = yn1;
42.
43.           xn1 = b * yn + f(xn);
44.           yn1 =  -xn + f(xn1);
45.           pnt.x = i * step;
46.           pnt.y = 300 + yn1 * scale;
47.           canvas.copyPixels(dot, dot.rect, pnt, null, null, true);
48.
49.     }
50. }

Try it out:

Gumowski Mira Pseudo-soundwave - wonderfl build flash online

## Closest Point on a Line

Actionscript:
1. // from
2. // http://www.gamedev.net/topic/444154-closest-point-on-a-line/
3.
4. function getClosestPoint(A:*, B:*, P:*, segmentClamp:Boolean=true):Point {
5.     var AP:Point = new Point(P.x - A.x, P.y - A.y),
6.         AB:Point = new Point(B.x - A.x, B.y - A.y);
7.     var ab2:Number=AB.x*AB.x+AB.y*AB.y;
8.     var ap_ab:Number=AP.x*AB.x+AP.y*AB.y;
9.     var t:Number=ap_ab/ab2;
10.     if (segmentClamp) {
11.         if (t<0.0) {
12.             t=0.0;
13.         } else if (t> 1.0) {
14.             t=1.0;
15.         }
16.
17.     }
18.     return new Point(A.x + AB.x * t, A.y + AB.y * t);
19. }
20.
21.
22. var point:Sprite = Sprite(addChild(new Sprite()));
23. point.x = 50;
24. point.y = 50;
25. with(point.graphics) beginFill(0), drawCircle(0,0, 3);
26.
27. var line:MovieClip = MovieClip(addChild(new MovieClip()));
28. line.a = new Point(20, 100);
29. line.b = new Point(300, 60);
30. with(line.graphics) lineStyle(0), moveTo(line.a.x, line.a.y), lineTo(line.b.x, line.b.y);
31.
32. var closestPoint:Point = getClosestPoint(line.a, line.b, point);
33.
34. var closest:Sprite = Sprite(addChild(new Sprite()));
35. closest.x = closestPoint.x;
36. closest.y = closestPoint.y;
37. with(closest.graphics) beginFill(0xFF0000), drawCircle(0,0, 3);

## Fish Curve

Actionscript:
1. var xp:Number = 0;
2. var yp:Number = 0;
3. var t:Number = 0;
4. var a:Number = 200;
5. x = stage.stageWidth / 2;
6. y = stage.stageHeight / 2;
7.
8. graphics.lineStyle(0,0x000000);
10. function onRun(evt:Event):void {
11.     xp = a * Math.cos(t) - (a * Math.pow(Math.sin(t),2))/Math.sqrt(2);
12.     yp = a * Math.cos(t) * Math.sin(t);
13.     if (t == 0){
14.       graphics.moveTo(xp, yp);
15.     }else{
16.       graphics.lineTo(xp, yp);
17.     }
18.     t += 0.05;
19. }

While surfing mathworld I stumbled upon the equation for something called the Fish Curve. This snippet will draw something like this: