User:Acheron Gloom

GetSubInteger

<lsl> integer getSubIntegerLowMem(integer x, integer place){

   integer tenExp = (integer)llPow(10.0, place);
   return (x/(tenExp/10)) - (x/tenExp)*10;

}

integer getSubIntegerFast(integer x, integer place){

   integer tenExp;
   if(place & 1){//1, 3, 5, 7, 9
       if(place & 2){//3, 7
           if(place & 4) tenExp = 10000000;
           else tenExp = 1000;
       }
       else{//1, 5, 9
           if(place & 4) tenExp = 100000;
           else if(place & 8) tenExp = 1000000000;
           else tenExp = 10;
       }
   }
   else{//2, 4, 6, 8, 10
       if(place & 2){//2, 6, 10
           if(place & 4) tenExp = 1000000;
           else{//2, 10
               if(place & 8) tenExp = 10000000000;
               else tenExp = 100;
           }
       }
       else{//4, 8
           if(place & 4) tenExp = 10000;
           else tenExp = 100000000;
       }
   }
   return (x/(tenExp/10)) - (x/tenExp)*10;

} <lsl>

IntegerLength

<lsl> integer getDigitsStrLen(integer x){//Low memory usage, but horrible performance. Don't use this, its just an example.

   return llStringLength((string)x);

}

integer getDigitsLog(integer x){//Low memory usage (35 bytes), good performance. Use this if memory is your main concern. You can probably in-line it for a small performance gain.

   return (integer)llLog10(x);

}

//The two functions below only work up to 8 digits. I use them for text prims. integer get8DigitsNoBranch(integer x){ //Decent memory usage (123 bytes), Better performance. Use this if you want a balanced method.

   return -~((x >= 10) + (x >= 100) + (x >= 1000) + (x >= 10000) + (x >= 100000) + (x >= 1000000) + (x >= 10000000));

}

integer get8DigitsTree(integer x){//High memory usage (239 bytes), best performance. Use this if you need speed. Inline if you need even more speed.

   if (x >= 10000) {
       if (x >= 10000000) return 8;
       if (x >= 100000){
           if (x >= 1000000) return 7;
           return 6;
       }
       return 5;
   }
   if (x >= 100){
       if (x >= 1000) return 4;
       return 3;
   }
   if (x >= 10) return 2;
   return 1;

}

//The two functions below work up to the integer max. I don't need them, but someone might. They're just minor modifications. integer getDigitsNoBranch(integer x){ //Decent memory usage (123 bytes), Better performance. Use this if you want a balanced method.

   return -~((x >= 10) + (x >= 100) + (x >= 1000) + (x >= 10000) + (x >= 100000) + (x >= 1000000) + (x >= 10000000) + (x >= 100000000) + (x >= 1000000000));

}

integer getDigitsTree(integer x){//High memory usage (239 bytes), best performance. Use this if you need speed. Inline if you need even more speed.

   if(x >= 10000) {
       if(x >= 10000000){
           if(x >= 100000000){
               if(x >= 1000000000) return 10;
               return 9;
           }
           return 8;
       }
       if(x >= 100000){
           if(x >= 1000000) return 7;
           return 6;
       }
       return 5;
   }
   if(x >= 100){
       if(x >= 1000) return 4;
       return 3;
   }
   if(x >= 10) return 2;
   return 1;

} </lsl>

Int2Prim

The following functions make use of a texture that I keep inside of the prim named 'n' to save memory. Each list-UUID otherwise would be tens of bytes per face. The texture is:

<lsl> list Int2PrimLeft(integer p, integer text, vector color){//left aligned

   faces=[];
   //i = getDigitsTree(text); OR i = getDigitsNoBranch(text);
   i = -~((text >= 10) + (text >= 100) + (text >= 1000) + (text >= 10000) + (text >=  100000) + (text >=  1000000) + (text >= 10000000));
   tenExp = 1;
   while(i) faces = [PRIM_TEXTURE, i=~-i, "n", <1.0, 0.1, 0.0>, <0.0, 0.55 + 0.1*((text/(tenExp*=10))*10 - text/tenExp), 0.0>, 0.0] + faces;
   return [PRIM_LINK_TARGET, p, PRIM_COLOR, ALL_SIDES, color, 1.0] + faces;

}

list Int2PrimRight(integer p, integer text, vector color){//Right aligned

   faces=[];
   ///i = getDigitsTree(text); OR i = getDigitsNoBranch(text);
   i = (counter = 8) + ~((text >= 10) + (text >= 100) + (text >= 1000) + (text >= 10000) + (text >=  100000) + (text >=  1000000) + (text >= 10000000));
   tenExp = 1;
   while(counter != i) faces = [PRIM_TEXTURE, counter=~-counter, "n", <1.0, 0.1, 0.0>, <0.0, 0.55 + 0.1*((text/(tenExp*=10))*10 - text/tenExp), 0.0>, 0.0] + faces;
   return [PRIM_LINK_TARGET, p, PRIM_COLOR, ALL_SIDES, color, 1.0] + faces;

} </lsl>