Dhhodgin

Contact Information

Name	Daniel Hodgin
Email	dhhodgin [AT] learn [DOT] senecac [DOT] on [DOT] ca
Email2	hodgin.daniel [AT] gmail [DOT] com
IRC	dhodgin
BLOG	[1]

About Me

I'm a 5th Semester BSD student taking DPS909. Working part time on an ASP.NET c# application.

Technical Qualifications

Programming Languages

C
C++
C#
Java
PHP/PERL
SQL

DPS909 Project

[Processing.js] - Active project
~~[Fennec and @font-face]~~ - on hold

Releases

0.1 - Full Details shorten(), expand(), nfs(), unhex(), bug fixes on nf() and fill()
0.2 - work in progress (nfc(), etc)

code blocks

Here is a list of code blocks I have written for the processing.js project

shorten()

Specification for shorten() in processing here.
Arrays in JS have no type, the elements in them can contain any type and do not all have to match. Arrays are also passed by reference which means a reference to the object is passed in not the entire object. so my code creates a new array and then copies the passed in array first and then pops one element off the new array and the newary object is returned. This is built to accept a processing type of String, int, boolean, char, byte, and float. Support for arrays of objects will be added in 0.2.

 p.shorten = function( ary ) {
   var newary = new Array();
   // copy ary into newary
   for ( var i = 0; i < size; i++ ) {
       newary[ i ] = ary[ i ];
   }
   newary.pop();
   return newary;
 }

Example of this function and test is here.
Known issues: This has not been tested with arrays of objects. I'm assuming it will copy object elements in an array by reference and not produce a proper deep copy. I plan to fix this by 0.2. (confirmed, needs deep copy support for arrays of objects).

expand()

Specification for expand() in processing here.
Expand takes an array as its argument and returns a copy of the array with its length doubled. There is an optional 2nd parameter to specify the new size of the array as well.

 p.expand = function( ary, newSize ) {
   var newary = new Array();
   for ( var i = 0; i < ary.length; i++ ) {
       newary[ i ] = ary[ i ];
   }
   if (arguments.length == 1) {
     // double size of array
     newary.length *= 2;
   }
   else if (arguments.length == 2) {
     // size is newSize
     newary.length = newSize;
   }
   return newary;
 }

Example of this function and test is here.
Known issues: Not yet tested with arrays of objects.

unhex()

Specification for unhex() in processing here.
unhex takes a string representing a 8 digit hex code as its only argument and returns an int representation of the string. JavaScript supports 64 bit floats as var's so it took a little number crunching to make it output an exact replication of the Java implementation with signed int's.

 p.unhex = function( str ) {
   var value = 0;
   var multiplier = 1;
   var num = 0;
   for (var i = str.length-1; i >= 0; i--){
       try{
           switch(str[i]){
               case "0": num = 0; break;
               case "1": num = 1; break;
               case "2": num = 2; break;
               case "3": num = 3; break;
               case "4": num = 4; break;
               case "5": num = 5; break;
               case "6": num = 6; break;
               case "7": num = 7; break;
               case "8": num = 8; break;
               case "9": num = 9; break;
               case "A":
               case "a": num = 10; break;
               case "B":
               case "b": num = 11; break;
               case "C": 
               case "c": num = 12; break;
               case "D":
               case "d": num = 13; break;
               case "E":
               case "e": num = 14; break;
               case "F":
               case "f": num = 15; break;
               default:return 0; break;
           }
           value += num * multiplier;
           multiplier *= 16;
       }catch(e){;}
       // correct for int overflow java expectation
       if (value > 2147483647)
       {
           value -= 4294967296;
       }  
   }
   return value;
 }

Example of this function and test is here.
Known issues: None.

nfs()

Specification for nfs() in processing here.
nfs() is a function used to format numbers as strings with padding of 0's on either the left or right of the decimal place. It accepts int, int[], float, and float[] types and returns either a single string or array of strings depending on the input.

 p.nfs = function( num, left, right){
   var str;
   // array handling
   if (typeof num == "object"){
     str = new Array();
     for(var i=0; i < num.length; i++){
       str[i] = p.nfs(num[i], left, right);
     }
   }
   else if (arguments.length == 3){
     var negative = false;
     if (num < 0)
       negative = true;
       
     str = "" + Math.abs(num);
     var digits = ("" + Math.floor(Math.abs(num))).length;
     var count = left - digits;
     while (count > 0){
       str = "0" + str;
       count--;
     }
     // get the number of decimal places, if none will be -1
     var decimals = ("" + Math.abs(num)).length - digits - 1;
     if (decimals == -1 && right > 0)
       str = str + ".";
     if (decimals != -1)
       count = right - decimals;
     else if (decimals == -1 && right > 0){
       count = right;
     }
     else
       count = 0;
     while (count > 0){
       str = str + "0";
       count--;
     }
     str = (negative ? "-" : " ") + str;
   }
   else if (arguments.length == 2){
     str = p.nfs(num, left, 0);
   }
   return str;
 }