# Monthly Archives: November 2009

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

Posted in Math, 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)

Posted in Math, misc | Tagged , , , | 1 Comment

## Fp10 3d Logo

Actionscript:
1. var container:Sprite = new Sprite();
2. container.x = stage.stageWidth / 2;
3. container.y = stage.stageHeight / 2;
5.
6. var redBox:Sprite = new Sprite();
7. redBox.graphics.beginFill(0xFF0000);
8. redBox.graphics.drawRect(-50,-250,100,500);
9. redBox.rotationZ = 10;
11.
12. var logos:Array = []
13. var elements:Array = [];
14. elements.push({element:redBox, z:0});
15.
17. for (var i:int = 0; i<6; i++){
18.     var logoContainer:MovieClip = new MovieClip();
19.     var logoText:TextField = new TextField();
20.     logoText.defaultTextFormat = new TextFormat("_sans", 50);
21.     logoText.text = "LOGO";
22.     logoText.autoSize = "left";
23.     logoText.selectable= false;
24.
25.     logoText.x = -logoText.width / 2;
26.     logoText.y = -logoText.height / 2;
28.     logoText.backgroundColor = 0xFFFFFF;
29.
31.     logos.push(logoContainer);
32.     elements.push({element:logoContainer, z:0});
33. }
34.
35. var ang:Number = -Math.PI / 2;
36. var rotationSpeed:Number = 0.05;
38. function onLoop(evt:Event):void {
39.
40.      var dx:Number = (mouseY - stage.stageHeight / 2) / 10;
41.      var dy:Number = (mouseX - stage.stageWidth / 2) / 10;
42.      container.rotationX += (dx - container.rotationX) / 4;
43.      container.rotationY += (dy - container.rotationY) / 4;
44.
45.      ang += rotationSpeed;
46.      for (var i:int = 0; i<logos.length; i++){
47.          var logo:Sprite = logos[i];
48.          logo.x = 150 * Math.cos(ang + i);
49.          logo.z = 150 * Math.sin(ang + i);
50.          logo.alpha = 1 - logo.z / 200;
51.          logo.rotationY = -Math.atan2(logo.z, logo.x)  / Math.PI * 180  - 90;
52.      }
53.
54.      // z-sort
55.      for (i = 0; i<elements.length; i++){
56.           elements[i].z = elements[i].element.transform.getRelativeMatrix3D(this).position.z;
57.      }
58.
59.     elements.sortOn("z", Array.NUMERIC | Array.DESCENDING);
60.     for (i = 0; i<elements.length; i++) {
62.     }
63. }

A student of mine was having trouble creating a 3D logo for a client. I created this snippet to help explain how some of the fp10 3D stuff works.... z-sorting etc... The code could be optimized a bit... but it works nicely...

Have a look at the swf... Posted in 3D, misc, motion | Tagged , , , | 2 Comments