Monthly Archives: January 2009

Adding Very Large Numbers

By Zevan | January 8, 2009
CLICK HERE TO COPY
Actionscript:
  1. // tracing out large numbers will go into exponent notation
  2. trace(1000000000000000000000000);
  3. // outputs: 1e+24
  4.  
  5. var a:String =  "1000000000000000000000009";
  6. var b:String = "12000000000000000000000001";
  7.  
  8. // bigAdd function adds two large numbers
  9. trace(bigAdd(a, b));
  10. // outputs: 13000000000000000000000010
  11.  
  12. // unclear what regular addition is doing here:
  13. trace(int(a) + int(b));
  14. // outputs: -3758096384
  15.  
  16. function bigAdd(a:String, b:String):String{
  17.        var answer:String="";
  18.        var carry:int = 0;
  19.        var zeros:int = 0;
  20.        var i:int = 0;
  21.        var max:int = 0;
  22.        
  23.         // obtain max variable and prepend zeros to the shortest string
  24.        if (a.length> b.length){
  25.           max = a.length;
  26.           zeros = max - b.length;
  27.            for (i= 0; i<zeros; i++) {
  28.                 b = "0" + b;
  29.            }
  30.        }else if (b.length>  a.length){
  31.            max = b.length;
  32.            zeros = max - a.length;
  33.            for (i= 0; i<zeros; i++) {
  34.                 a = "0" + a  ;
  35.             }
  36.        }else{
  37.            // a and b have same number of digets
  38.            max = a.length;  
  39.        }
  40.        
  41.        // add each character starting with the last (max - 1),
  42.        // carry the 1 if the sum has a length of 2
  43.        for (i = max - 1;  i> -1; i--){
  44.                var sum:String = String(int(a.charAt(i)) + int(b.charAt(i)) + carry);
  45.  
  46.                if (sum.length == 2){
  47.                        answer = sum.charAt(1) + answer;
  48.                        carry = 1;
  49.                }else{
  50.                        carry = 0;
  51.                        answer = sum + answer;
  52.                }
  53.        }
  54.        if (carry == 1){
  55.            answer = 1 + answer;
  56.        }
  57.        return answer;
  58. }

This snippet demos a function called bigAdd(), which can be used to add very large numbers that the standard numerical datatypes (int, Number, etc) won't really work with. It uses a string based addition algorithm.

When I decided to write this snippet I dug around for awhile trying to find a nice elegant algorithm to port, something done without prepending zeros etc.... but I couldn't find one that suited my needs... so I just created this one from scratch. There's room for optimization and improvement but it works well enough for just playing around.

BigDecimal & BigInteger

A few months back I needed to do some programming with very large numbers. I dug around for awhile and eventually found out that java has a built in BigInteger andBigDecimal class.... I used java to write the program I had in mind, but thought it would be fun to eventually create something similar for ActionScript....

Posted in Number, misc, string manipulation, strings | Tagged , , , , | 2 Comments

E?

By Zevan | January 7, 2009
CLICK HERE TO COPY
Actionscript:
  1. trace(Math.pow((1+1/10000000),10000000));
  2.  
  3. trace(Math.E);
  4.  
  5. /*outputs :
  6.  
  7. 2.7182816939803724
  8. 2.718281828459045
  9.  
  10. */

E

2.7182818284590452353602874713526624977572470936999595749669676277240766303535
47594571382178525166427427466391932003059921817413596629043572900334295260595630
73813232862794349076323382988075319525101901157383418793070215408914993488416750
92447614606680822648001684774118537423454424371075390777449920695517027618386062
61331384583000752044933826560297606737113200709328709127443747047230696977209310
14169283681902551510865746377211125238978442505695369677078......

Posted in misc, one-liners | Tagged , | Comments closed

Clamp Math.max(Math.min())

By Zevan | January 6, 2009
CLICK HERE TO COPY
Actionscript:
  1. // this one-liner is good to know:
  2. // Math.max(minValue, Math.min(maxValue, valueToClamp));
  3.  
  4. // wrapped in a function it looks like this:
  5. const MIN:Number = 0;
  6. const MAX:Number = 100;
  7.  
  8. function clamp(val:Number, min:Number = MIN, max:Number = MAX){
  9.     return Math.max(min, Math.min(max, val))
  10. }
  11.  
  12. for (var i:int = 0; i<1000; i++){
  13.     var val:Number = Math.random()*1000 - 500;
  14.     // clamp the above random value between -100 and +100
  15.     trace(clamp(val, -100, 100));
  16. }

Although I show a function implementation above, I use this technique inline a good deal. If there is some value that I need to clamp I'll often just "max min it":

CLICK HERE TO COPY
Actionscript:
  1. var val:Number = Math.random()*1000;
  2. // clamp it - 0-100
  3. trace(Math.max(0, Math.min(100, val));

Posted in misc, one-liners | Tagged , | 1 Comment

Constants as Function Argument Defaults

By Zevan | January 5, 2009
CLICK HERE TO COPY
Actionscript:
  1. const RADIUS = 10;
  2. const COLOR = 0xCCCCCC;
  3.  
  4. function createCircle(xp:Number, yp:Number, radius:Number = RADIUS, col:uint = COLOR):void{
  5.     var c:Sprite = new Sprite();
  6.     c.graphics.beginFill(col);
  7.     c.graphics.drawCircle(xp, yp, radius);
  8.     addChild(c);
  9. }
  10.  
  11. // optional last 2 values are populated with const defaults
  12. createCircle(100,100);
  13. // optional color value is populated with default 0xCCCCCC;
  14. createCircle(200,100, 20);
  15. //
  16. createCircle(300,100, 50,0x0000FF);

Posted in functions, variables | Tagged , | Leave a comment