flash on 2013-3-1

/**
 * Copyright mutantleg ( http://wonderfl.net/user/mutantleg )
 * MIT License ( http://www.opensource.org/licenses/mit-license.php )
 * Downloaded from: http://wonderfl.net/c/5eSa
 */

package {
    import flash.text.TextField;
    import flash.display.Sprite;
    public class FlashTest extends Sprite {
        
        public var deb:TextField;
        
        public function FlashTest() {
            // write as3 code here..
            
            deb = new TextField();
            addChild(deb);
            deb.width = 400;
            deb.height = 400;
            
            var test:Vector.<int> = Vector.<int>([213218,232,532,2,50,0,1,23]);
            
            deb.text ="";
   
            deb.appendText(getStrFromVec(test) + "\n");
            
            radixSort(test, test.length);
            
            deb.appendText(getStrFromVec(test) + "\n");
            
        }//ctor
        
        public function getStrFromVec(vec:Vector.<int>):String
        {
            var ret:String;
            var i:int;
            var num:int;
            
            num = vec.length;
            
            ret = "["
            
            for (i = 0; i < num; i++)
            {
                ret += vec[i] + ((i == num -1) ? " " : ", ");
            }//nexti
            
            ret += "]";
            
            return ret;
        }//getstr
        
        
        
        
        
        //this is the wikipedia radix sort example
        //modified to work on base 16 instead of base 10
        //bitsort (base 2) is probably faster but i cant be bothered 
        //http://en.wikipedia.org/wiki/Radix_sort


        //just to avoid allocating everytime it's called
        public var tempVec:Vector.<int> = new Vector.<int>(4096, false);
        public var tempBuck:Vector.<int> = new Vector.<int>(16, false);
        
        public function radixSort(vec:Vector.<int>, num:int):void
        {
          var temp:Vector.<int>;
          var buck:Vector.<int>;
          var m:int;
          var i:int;
          var k:int;
          var shift:int;
          
          
          if (vec.length > num) { num = vec.length; }
          
          
          temp = tempVec;
          
          //todo -- resize when vec is larger than max
          if (temp.length < num) { return; }
        
         
          buck = tempBuck;
          shift = 0;
          m = vec[0];
          
          for (i = 0; i < num; i++)
          {
            if (vec[i] > m) { m = vec[i]; }
          }
          
          while ((m >> shift) > 0)
          {
            //reset bucket
            for (k = 0; k < 16; k++)
            { buck[k] = 0; }
          
            
            for (i = 0; i < num; i++)
            {
              buck[(vec[i] >> shift) % 16]++;
            }
           
            for (i = 1; i < 16; i++) 
            {
              buck[i] += buck[i - 1];
            }
           
            for (i = num - 1; i >= 0; i--)
            {
              temp[--buck[(vec[i] >> shift) % 16]] = vec[i];
            }
           
            for (i = 0; i < num; i++)
            {
              vec[i] = temp[i];
            }
           
            shift += 4;
          
          }//wend
        
        
        }//radixsort

    }//classend
}