docs: function analyzeNumericArray( v, include_costly ) {
  	var min = v[0], max = min, is_int = false, is_float = false, is_same = true,
  		dmin=0, dmax=0, is_dfloat = false,
  		mean=0, n_type=0, d_mode=0, f_type=[0, NUMTYPE.UNKNOWN], 
  		c_same=0, same=0,
  		s_min = [min,min,min,min,min], s_min_i=0, s_max = [min,min,min,min,min], s_max_i=0, samples,
  		a, b, d_type, cd, cv, lv = v[0];
  
  	// Anlyze array items
  	for (var i=0, l=v.length; i<l; ++i) {
  		cv = v[i];
  
  		// Exit on non-numeric cases
  		if (typeof cv !== 'number')
  			return null;
  
  		// Update mean
  		mean += cv;
  
  		// Include costly calculations if enabled
  		if (include_costly) {
  
  			// Update delta
  			if (i !== 0) {
  				cd = lv - cv; if (cd < 0) cd = -cd;
  				if (i === 1) {
  					dmin = cd;
  					dmax = cd;
  				} else {
  					if (cd < dmin) dmin = cd;
  					if (cd > dmax) dmax = cd;
  				}
  
  				// Check if delta is float
  				if ((cd !== 0) && (cd % 1 !== 0))
  					is_dfloat = true;
  			}
  
  			// Update bounds & Keep samples
  			if (cv < min) {
  				min = cv;
  				s_min[s_min_i] = cv;
  				if (++s_min_i>5) s_min_i=0;
  			}
  			if (cv > max) {
  				max = cv;
  				s_max[s_max_i] = cv;
  				if (++s_max_i>5) s_max_i=0;
  			}
  
  		} else {
  
  			// Update bounds
  			if (cv < min) min = cv;
  			if (cv > max) max = cv;
  
  		}
  
  		// Check for same values
  		if (cv === lv) {
  			c_same++;
  		} else {
  			if (c_same > same)
  				same = c_same;
  			is_same = false;
  			c_same = 0;
  		}
  
  		// Keep last value
  		lv = cv;
  
  		// Skip zeros from further analysis
  		if (cv === 0) continue;
  
  		// Update integer/float
  		if (cv % 1 !== 0) {
  			is_float = true;
  		} else {
  			is_int = true;
  		}
  
  	}
  
  	// Finalize counters
  	if (c_same > same) same = c_same;
  	mean /= v.length;
  
  	// Guess numerical type
  	n_type = getNumType( min, max, is_float );
  
  	// Calculate delta-encoding details
  	d_type = NUMTYPE.UNKNOWN;
  	if (include_costly) {
  		if (!is_float && is_int) {
  
  			// INTEGERS : Use Delta-Encoding (d_mode=1)
  
  			if ((dmin > INT8_MIN) && (dmax < INT8_MAX)) {
  				d_type = NUMTYPE.INT8;
  				d_mode = 1;
  			} else if ((dmin > INT16_MIN) && (dmax < INT16_MAX)) {
  				d_type = NUMTYPE.INT16;
  				d_mode = 1;
  			} else if ((dmin > INT32_MIN) && (dmax < INT32_MAX)) {
  				d_type = NUMTYPE.INT32;
  				d_mode = 1;
  			}
  
  		} else if (is_float) {
  
  			// FLOATS : Use Rebase Encoding (d_mode=2)
  
  			// Get a couple more samples
  			samples = [].concat(
  				s_min, s_max,
  				[
  					v[Math.floor(Math.random()*v.length)],
  					v[Math.floor(Math.random()*v.length)],
  					v[Math.floor(Math.random()*v.length)],
  					v[Math.floor(Math.random()*v.length)],
  					v[Math.floor(Math.random()*v.length)],
  				]
  			);
  
  			// Calculate float scale
  			f_type = getFloatScale( v, min, max, 0.01 );
  			if (f_type[1] != NUMTYPE.UNKNOWN) {
  				d_type = f_type[1];
  				d_mode = 2;
  			}
  
  		}
  	}
  
  	// Based on information detected so far, populate
  	// the analysis results
  	return {
  
  		// Get numeric type
  		'type'		: n_type,
  		'delta_type': d_type,
  
  		// Percentage of same items
  		'psame'		: same / v.length,
  
  		// Log numeric bounds
  		'min'		: min,
  		'max'		: max,
  		'mean'		: mean,
  
  		// Log delta bounds
  		'dmin'		: dmin,
  		'dmax' 		: dmax,
  
  		// Delta mode
  		'dmode'		: d_mode,
  		'fscale' 	: f_type[0],
  
  		// Expose information details
  		'integer' 	: is_int && !is_float,
  		'float' 	: is_float && !is_int,
  		'mixed' 	: is_float && is_int,
  		'same'		: is_same && (v.length > 1),
  
  	};
  
  }