# Category Archives: Math

## Astroid Pedal Curve Variation

Actionscript:
1. var xp:Number = 0;
2. var yp:Number = 0;
3. var t:Number = 0;
4. var r: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.     r = 200 * Math.cos(t / 10);
12.     xp = r * Math.pow(Math.cos(t), 3);
13.     yp = r * Math.pow(Math.sin(t), 3);
14.     if (t == 0){
15.       graphics.moveTo(xp, yp);
16.     }else{
17.       graphics.lineTo(xp, yp);
18.     }
19.     t += 0.1;
20. }

While browsing mathworld I decided to do a variation on this curve . The above snippet will draw something like this: ## Logistic Map Play

Actionscript:
1. var offX:Number = 100;
2. var offY:Number = 300;
3. var scalarX:Number = 6;
4. var scalarY:Number = 200;
6. function onLoop(evt:Event):void{
7.     var r:Number = mouseY / 100;
8.     var xn:Number = (mouseX - 100) / 650;
9.     var xn1:Number = 0;
10.     graphics.clear();
11.     graphics.lineStyle(0,0);
12.     for (var i:int = 0; i<100; i++){
13.       xn1 = r * xn * (1 - xn);
14.       xn = xn1;
15.       if (i == 0){
16.         graphics.moveTo(offX+i*scalarX,offY+xn1*scalarY);
17.       }else{
18.         graphics.lineTo(offX+i*scalarX, offY+xn1*scalarY);
19.       }
20.     }
21. }

Whenever I can't decide what kind of snippet to make, I simply go to wikipedia or mathworld for a bit and I always end up with something. I've messed with Logistic Maps before (when learning about strange attractors). This is a simple rendering where the x and y axis change the biotic potential (r) and the starting value for x.

Here is the link I used for reference.

Have a look at the swf (just move your mouse around). Also posted in Graphics, misc | Tagged , , | 2 Comments

## Connect The Dots E8

Actionscript:
1. [SWF(width = 500, height = 500)]
2. const TWO_PI:Number = Math.PI * 2;
3. var centerX:Number = stage.stageWidth / 2;
4. var centerY:Number = stage.stageHeight / 2;
6. function onLoop(evt:Event):void{
7.     // data
8.     var points:Array = [];
9.     var i:int = 0;
10.     var pointNum : int = Math.max(2,int(mouseX / 12))
11.
13.     var step:Number = TWO_PI / pointNum;
14.     var theta:Number = step / 2;
15.     for (i = 0; i<pointNum; i++){
16.         var xp:Number = centerX + radius * Math.cos(theta);
17.         var yp:Number = centerY + radius * Math.sin(theta);
18.         points[i] = new Point(xp, yp);
19.         theta += step;
20.     }
21.     // render
22.     graphics.clear();
23.     graphics.lineStyle(0,0);
24.     for ( i = 0; i<pointNum; i++){
25.      var a:Point = points[i];
26.      for (var j:int = 0; j<pointNum; j++){
27.         var b:Point = points[j];
28.         if (a != b){
29.            graphics.drawCircle(a.x, a.y, 10);
30.            graphics.moveTo(a.x, a.y);
31.            graphics.lineTo(b.x, b.y);
32.         }
33.      }
34.    }
35. }

I've been using this geometric shape for lots of different things recently. Including during consulting gigs as a helpful visualization. Just move your mouse left and right... I particularly like the simpler forms you get by moving your mouse to the left (triangles squares and simple polygons):

While not entirely related this wikipedia article is interesting.

[EDIT : Thanks to martin for reminding me that I can do away with the if statement here in the above code ]

Actionscript:
1. graphics.clear();
2. graphics.lineStyle(0,0);
3. for (i = 0; i<pointNum; i++) {
4.     var a:Point=points[i];
5.     for (var j:int = i+1; j<pointNum; j++) {
6.         var b:Point=points[j];
7.         graphics.drawCircle(a.x, a.y, 10);
8.         graphics.moveTo(a.x, a.y);
9.         graphics.lineTo(b.x, b.y);
10.     }
11. }
12. graphics.drawCircle(a.x, a.y, 10);

I implemented that change over at wonderfl and it works nicely

Also posted in Graphics, misc | Tagged , , | 4 Comments

## Polar Coordinates Distribution

If you're at all interested in watching me free from code. I recorded a video of me coding this snippet (which is about 11 minutes long or so).

In the video I create a few functions that allow you to draw shapes like these: Mathematically this stuff is really simple ... the free form nature of the video takes a less technical perspective as you'll see (I even made a few funny mistakes).

Actionscript:
1. [SWF(width = 600, height = 600)]
2. var dotNum:int = 1000;
4.
5. x = 120
6. y = 100;
7.
8. // extra stuff to display what the functions can do
10.
11. function onDrawAll(evt:Event):void{
12.     graphics.clear();
13.     for (var i:int = 0; i<16; i++){
14.         var m:Number;
15.
17.         var xp:Number = i % 4 * rad
18.         var yp:Number = int(i / 4) * rad
19.
20.         var type:int = int(Math.random() * 4);
21.         if (type == 0){
22.           makeShape(xp, yp, rad-60, Math.random() , 1);
23.         }else if (type == 1){
24.            makeShape(xp, yp, rad-60, 1,  Math.random());
25.         }
26.         else if (type == 2){
27.            m = Math.random() * 2;
28.            makeShape(xp, yp, rad-Math.random()*120, m, m);
29.         }
30.         else if (type == 3){
31.            m = Math.random() * 2;
32.            makeShape(xp, yp, rad-Math.random()*120, m, m/2);
33.         }
34.     }
35. }
36.
37. // main part from the video
38. function makeShape(xp:Number, yp:Number,
40.                    m1:Number=1):void{
41.     var polarX:Number;
42.     var polarY:Number;
44.     graphics.lineStyle(0, 0);
45.     var theta:Number = Math.random() * Math.PI * 2;
46.     for (var i:int = 0; i<dotNum; i++){
48.         polarX = xp + radius * Math.cos(theta * m0);
49.         polarY = yp + radius * Math.sin(theta * m1);
50.         theta += 0.1;
51.
52.         makeDot(polarX, polarY);
53.
54.     }
55. }
56.
57. function makeDot(xp:Number, yp:Number, fillColor:uint = 0x000000):void{
58.     graphics.beginFill(fillColor);
60.     graphics.endFill();
61. }

Here it is over at wonderf:

Also posted in Graphics, functions, misc | Tagged , , | 4 Comments

## Prefix Notation (Lisp Style)

Today's quiz is not multiple choice. Instead, your task is to write a lisp style math parser. This may sound tricky, but it's surprisingly simple. (well... not simple exactly, it's just simple compared to what one might assume).

Lisp uses prefix notation... where the operator is placed before the operands:

10 * 10

becomes:

* 10 10

You could think of this as a function "*" with two arguments (10, 10). In Lisp this is enclosed with parens:

(* 10 10)

Let's see a few more examples:

100 / 2 + 10

becomes:

(+ (/ 100 2) 10)

...
2 * 4 * 6 * 7

becomes:

(* 2 4 6 7)

...

(2 + 2) * (10 - 2) * 2

becomes

(* (+ 2 2) (- 10 2) 2)

Remember, thinking "functions" really helps. The above can be though of as:

multiply( add(2, 2), subtract(10 , 2), 2)

You should create a function called parsePrefix() that takes a string and returns a number:

Here is some code to test if your parser works properly:

Actionscript:
1. trace(parsePrefix("(* 10 10)"));
2.
3. trace(parsePrefix("(* 1 (+ 20 2 (* 2 7) 1) 2)"));
4.
5. trace(parsePrefix("(/ 22 7)"));
6.
7. trace(parsePrefix("(+ (/ 1 1) (/ 1 2) (/ 1 3) (/ 1 4))"));
8.
9. /* Should trace out:
10. 100
11. 74
12. 3.142857142857143
13. 2.083333333333333
14. */

I highly recommend giving this a try, it was one of those cases where I assumed it would be much trickier than it was.

I've posted my solution here.

Also posted in Quiz | Tagged , , , , | 4 Comments

## Float as a Fraction

Actionscript:
1. // print some floats as fractions
2. printFraction(0.5);
3. printFraction(0.75);
4. printFraction(0.48);
5.
6. // try something a little more complex
7. var float:Number = 0.98765432;
8. trace("\na more complex example:");
9. printFraction(float);
10. var frac:Array = asFraction(float);
11. trace("double check it:");
12. trace(frac + "/" + frac +" = " + frac / frac);
13.
14. /* outputs:
15. 0.5 = 1/2
16. 0.75 = 3/4
17. 0.48 = 12/25
18.
19. a more complex example:
20. 0.98765432 = 12345679/12500000
21. double check it:
22. 12345679/12500000 = 0.98765432
23. */
24.
25.
26. function printFraction(n:Number):void{
27.     var frac:Array = asFraction(n);
28.     trace(n + " = " + frac + "/" + frac);
29. }
30.
31. // takes any value less than one and returns an array
32. // with the numerator at index 0 and the denominator at index 1
33. function asFraction(num:Number):Array{
34.     var decimalPlaces:int = num.toString().split(".").length;
35.     var denom:Number = Math.pow(10, decimalPlaces);
36.     return reduceFraction(num * denom, denom);
37. }
38.
39. // divide the numerator and denominator by the GCF
40. function reduceFraction(numerator:int, denominator:Number):Array{
41.     // divide by the greatest common factor
42.     var divisor:int = gcf(numerator, denominator);
43.     if (divisor){
44.         numerator /= divisor;
45.         denominator /= divisor;
46.     }
47.     return [numerator, denominator];
48. }
49.
50. // get the greatest common factor of two integers
51. function gcf(a:int, b:int):int{
52.     var remainder:int;
53.     var factor:Number = 0;
54.     var maxIter:int = 100;
55.     var i:int = 0;
56.     while (1){
57.         if (b> a){
58.            var swap:int = a;
59.            a = b;
60.            b = swap;
61.         }
62.         remainder = a % b;
63.         a = b;
64.         b = remainder
65.         if (remainder == 0){
66.             factor = a;
67.             break;
68.         }else if (remainder==1){
69.             break;
70.         }else if (i> maxIter){
71.             trace("failed to calculate gcf");
72.             break;
73.         }
74.         i++;
75.     }
76.     return factor;
77. }

This snippet contains a few functions for calculating fractions based on float values. Writing this brought back some memories from grade school math.

Also posted in misc | Tagged , , | 4 Comments

## Greatest Common Factor (divisor)

Actionscript:
1. trace(gcf(75,145));
2.
3. // outputs 5
4.
5. function gcf(a:int, b:int):int{
6.     var remainder:int;
7.     var factor:Number = 0;
8.     while (1){
9.         if (b> a){
10.            var swap:int = a;
11.            a = b;
12.            b = swap;
13.         }
14.         remainder = a % b;
15.         a = b;
16.         b = remainder
17.         if (remainder == 0){
18.             factor = a;
19.             break;
20.         }else if (remainder==1){
21.
22.             break;
23.         }
24.     }
25.     return factor;
26. }

I was messing around with Egyptian Fractions and found myself in need of some interesting functions. The first function I realized I would be needing was for a greatest common factor (GCF or GCD).

The above snippet is a quick implementation of Euclid's algorithm. It will return 0 if no GCF is found...

I wrote a few helper functions while working with Egyptian fractions... will post them over the next few days.

Posted in Math | Tagged , , | 4 Comments

## Ancient Egyptian Multiplication

Actionscript:
1. egyptianMultiply(12, 99);
2.
3. // trace(12 * 99) // test to make sure it works
4.
5. /* outputs:
6. /64 768
7. /32 384
8.  16 192
9.  8 96
10.  4 48
11. /2 24
12. /1 12
13. ---
14. 1188
15. */
16.
17.
18. function egyptianMultiply(valueA:Number, valueB:Number):void {
19.
20.     var left:Array = [];
21.     var right:Array = []
22.
23.     // swap if valueB is smaller than value A
24.     if (valueB <valueA){
25.         var swap:int = valueB;
26.         valueB = valueA;
27.         valueA = swap;
28.     }
29.
30.     // create left and right columns
31.     var currentLeft:int = 1;
32.     var currentRight:int = valueA;
33.
34.     while (currentLeft <valueB){
35.         left.push(currentLeft);
36.         right.push(currentRight);
37.         currentRight += currentRight;
38.         currentLeft += currentLeft;
39.     }
40.
41.
42.     // add up the right column based on the left
43.     currentLeft = 0;
44.     var rightSum:int;
45.     var leftSum:int;
46.     var i:int = left.length - 1;
47.
48.     while (currentLeft != valueB){
49.
50.       leftSum = currentLeft + left[i];
51.       // if the next number causes the sum
52.       // to go above valueB, skip it
53.       if (leftSum <= valueB){
54.         currentLeft = leftSum;
55.         rightSum += right[i];
56.         trace("/" + left[i]  + " " + right[i]);
57.       } else {
58.         trace(" " + left[i]  + " " + right[i]);
59.       }
60.       i--;
61.     }
62.     trace("---");
63.     trace(rightSum);
64. }

Someone mentioned egyptian multiplication to me yesterday... So read a little about it here and whipped up this example. For some reason I decided to do it in processing ... once it worked I ported it to ActionScript.

The above link describing the technique I used is from http://www.jimloy.com/... I haven't spent much time digging around the site, but it appears to have some pretty nice stuff on it...

If you're curious, here is the original processing version:

JAVA:
1. Vector left = new Vector();
2. Vector right = new Vector();
3.
4. int valueA = 10;
5. int valueB = 8;
6.
7. if (valueB <valueA){
8.     int swap = valueB;
9.     valueB = valueA;
10.     valueA = swap;
11. }
12.
13. int currentLeft = 1;
14. int currentRight = valueA;
15. while (currentLeft <valueB){
18.     currentRight += currentRight;
19.     currentLeft += currentLeft;
20. }
21.
22. currentLeft = 0;
23.
24. int result = 0;
25. int i = left.size() - 1;
26. while (currentLeft != valueB){
27.
28.   int temp = currentLeft + (Integer) left.get(i);
29.   if (temp <= valueB){
30.
31.     currentLeft = temp;
32.     result += (Integer) right.get(i);
33.     println("/" + left.get(i) + " " + right.get(i));
34.   } else {
35.     println(" " + left.get(i)  + " " + right.get(i));
36.   }
37.
38.   i--;
39. }
40. println("---");
41. println(result);

After writing, this I took a look at the wikipedia entry... I also found myself on this short page about a scribe called Ahmes. (I recommend reading this if you are interested in PI)

Also posted in misc | Tagged , , , | 1 Comment

## Triangular Numbers

Actionscript:
1. [SWF(width = 500, height = 500)]
2.
3. var txt:TextField = TextField(addChild(new TextField()));
4. txt.defaultTextFormat = new TextFormat("_sans", 4);
5. txt.width = stage.stageWidth;
6. txt.height = stage.stageHeight+4;
7. txt.z = -1;
8. txt.x = stage.stageWidth
9. txt.rotation = 90;
10. var count:int = 0;
12. function onLoop(evt:Event):void{
13.      count++;
14.      txt.appendText(triangular(count).toString(2) + "\n");
15.      txt.scrollV= txt.maxScrollV;
16. }
17. function triangular(n:int):int{
18.        return (n * (n + 1)) / 2;
19. }

Calculate some triangular numbers... (n * (n + 1)) / 2....

Check out the swf on wonderfl

## Flowing Leaves (optical illusion) Saw this optical illusion today... figured I'd make a snippet to create a few variations on the illusion...

Actionscript:
1. [SWF( backgroundColor=0x2E7999, width=780, height = 600) ]
2.
3. var leafNum:Number = 375;
4. var spacing:Number = 12;
5. var cols:Number = 25;
6. var hh:Number = stage.stageHeight / 2;
7. var hw:Number = stage.stageWidth / 2;
8.
9. for (var i:Number = 0; i<leafNum; i++){
10.     var leaf:Shape = makeLeaf();
11.     leaf.scaleX = leaf.scaleY = 0.25;
12.     leaf.rotation = 90;
13.     leaf.x = 50 + (i % cols) * (leaf.width + spacing);
14.     leaf.y = 40 + int(i / cols) * (leaf.height + spacing);
15.     var dx:Number = leaf.x - hw;
16.     var dy:Number = leaf.y - hh;
17.     leaf.rotation = Math.sqrt(dx * dx + dy * dy);
18. }
19.
20. function makeLeaf():Shape{
21.     var leaf:Shape = Shape(addChild(new Shape()));
22.     leaf.graphics.beginFill(0x9DC4D4);
23.     scaleYcircle(leaf.graphics, 50, .65, false);
24.     leaf.graphics.endFill();
25.     leaf.graphics.lineStyle(2, 0x003366, 1, false, "none", CapsStyle.SQUARE, JointStyle.MITER);
26.     scaleYcircle(leaf.graphics, 50, .65);
27.     leaf.graphics.lineStyle(2, 0xFFFFFF, 1, false, "none", CapsStyle.SQUARE, JointStyle.MITER);
28.     scaleYcircle(leaf.graphics, -50, .65);
29.     return leaf;
30. }
31.
32.
34. // circle that can be scaled on the y axis
35. function scaleYcircle(g:Graphics, r:Number, s:Number = 1, isHalf:Boolean=true):void {
36.
37.     var c1:Number = r * (Math.SQRT2 - 1);
38.     var c2:Number = r * Math.SQRT2 / 2;
39.     var rs:Number = r * s, c1s:Number = c1 * s, c2s:Number = c2 * s;
40.     var x_r:Number =  -r, y_r:Number = -rs, x_c2:Number =  -c2;
41.     var y_c2:Number =  -c2s, x_c1:Number =  -c1, y_c1:Number =  -c1s
42.     g.moveTo(r, 0), g.curveTo(r, c1s, c2, c2s);
43.     g.curveTo(c1, rs, 0, rs), g.curveTo(x_c1,rs, x_c2, c2s);
44.     g.curveTo(x_r, c1s, x_r, 0);
45.     if (!isHalf){
46.      g.curveTo(x_r,y_c1,x_c2,y_c2);
47.      g.curveTo(x_c1,y_r,0,y_r), g.curveTo(c1,y_r,c2,y_c2);
48.      g.curveTo(r,y_c1,r,0);
49.     }
50. }

Also posted in Graphics, Vector, misc, motion, pixel manipulation | Tagged , , , | 5 Comments

• 