blacklight_heatmaps 1.3.1 → 1.4.0

data/vendor/assets/javascripts/geostats.js

@@ -1,7 +1,7 @@
 /**
-* geostats() is a tiny and standalone javascript library for classification 
+* geostats() is a tiny and standalone javascript library for classification
 * Project page - https://github.com/simogeo/geostats
-* Copyright (c) 2011 Simon Georget, http://www.empreinte-urbaine.eu
+* Copyright (c) 2011 Simon Georget, http://www.intermezzo-coop.eu
 * Licensed under the MIT license
 */
 
@@ -85,13 +85,13 @@ var geostats = function(a) {
 	this.is_uniqueValues = false;
 	this.debug =  false;
 	this.silent = false;
-	
+
 	this.bounds  = Array();
 	this.ranges  = Array();
 	this.inner_ranges  = null;
 	this.colors  = Array();
 	this.counter = Array();
-	
+
 	// statistics information
 	this.stat_sorted	= null;
 	this.stat_mean 		= null;
@@ -104,62 +104,62 @@ var geostats = function(a) {
 	this.stat_stddev	= null;
 	this.stat_cov		= null;
 
-	
+
 	/**
 	 * logging method
 	 */
 	this.log = function(msg, force) {
-	
+
 		if(this.debug == true || force != null)
 			console.log(this.objectID + "(object id) :: " + msg);
-		
+
 	};
-	
+
 	/**
 	 * Set bounds
 	 */
 	this.setBounds = function(a) {
-		
+
 		this.log('Setting bounds (' + a.length + ') : ' + a.join());
-	
+
 		this.bounds = Array() // init empty array to prevent bug when calling classification after another with less items (sample getQuantile(6) and getQuantile(4))
-		
+
 		this.bounds = a;
 		//this.bounds = this.decimalFormat(a);
-		
+
 	};
-	
+
 	/**
 	 * Set a new serie
 	 */
 	this.setSerie = function(a) {
-		
+
 		this.log('Setting serie (' + a.length + ') : ' + a.join());
-	
+
 		this.serie = Array() // init empty array to prevent bug when calling classification after another with less items (sample getQuantile(6) and getQuantile(4))
 		this.serie = a;
-		
+
 		//reset statistics after changing serie
 	    this.resetStatistics();
-	    
+
 		this.setPrecision();
-		
+
 	};
-	
+
 	/**
 	 * Set colors
 	 */
 	this.setColors = function(colors) {
-		
+
 		this.log('Setting color ramp (' + colors.length + ') : '  + colors.join());
-		
+
 		this.colors = colors;
-		
+
 	};
-	
+
 	/**
 	 * Get feature count
-	 * With bounds array(0, 0.75, 1.5, 2.25, 3); 
+	 * With bounds array(0, 0.75, 1.5, 2.25, 3);
 	 * should populate this.counter with 5 keys
 	 * and increment counters for each key
 	 */
@@ -167,19 +167,25 @@ var geostats = function(a) {
 
 		if (this._nodata())
 			return;
-		
+
 
 		var tmp = this.sorted();
-		
+
 		this.counter = new Array();
-		
+
 		// we init counter with 0 value
-		for(i = 0; i < this.bounds.length -1; i++) {
-			this.counter[i]= 0;
+		if(this.is_uniqueValues == true) {
+			for (var i = 0; i < this.bounds.length; i++) {
+				this.counter[i]= 0;
+			}
+		} else {
+			for (var i = 0; i < this.bounds.length -1; i++) {
+				this.counter[i]= 0;
+			}
 		}
-		
-		for(j=0; j < tmp.length; j++) {
-			
+
+		for (var j=0; j < tmp.length; j++) {
+
 			// get current class for value to increment the counter
 			var cclass = this.getClass(tmp[j]);
 			this.counter[cclass]++;
@@ -187,239 +193,262 @@ var geostats = function(a) {
 		}
 
 	};
-	
+
 	/**
 	 * Set decimal precision according to user input
 	 * or automatcally determined according
 	 * to the given serie.
 	 */
 	this.setPrecision = function(decimals) {
-		
+
 		// only when called from user
 		if(typeof decimals !== "undefined") {
 			this.precisionflag = 'manual';
 			this.precision = decimals;
 		}
-		
+
 		// we calculate the maximal decimal length on given serie
 		if(this.precisionflag == 'auto') {
-			
+
 			for (var i = 0; i < this.serie.length; i++) {
-				
+
 				// check if the given value is a number and a float
 				if (!isNaN((this.serie[i]+"")) && (this.serie[i]+"").toString().indexOf('.') != -1) {
 					var precision = (this.serie[i] + "").split(".")[1].length;
 				} else {
 					var precision = 0;
 				}
-				
+
 				if(precision > this.precision) {
 					this.precision = precision;
 				}
-				
+
 			}
-			
+
+		}
+		if(this.precision > 20) {
+			// prevent "Uncaught RangeError: toFixed() digits argument must be between 0 and 20" bug. See https://github.com/simogeo/geostats/issues/34
+			this.log('this.precision value (' + this.precision + ') is greater than max value. Automatic set-up to 20 to prevent "Uncaught RangeError: toFixed()" when calling decimalFormat() method.');
+			this.precision = 20;
 		}
 
 		this.log('Calling setPrecision(). Mode : ' + this.precisionflag + ' - Decimals : '+ this.precision);
-		
+
 		this.serie = this.decimalFormat(this.serie);
-		
+
 	};
-	
+
 	/**
 	 * Format array numbers regarding to precision
 	 */
 	this.decimalFormat = function(a) {
-		
+
 		var b = new Array();
-		
+
 		for (var i = 0; i < a.length; i++) {
 			// check if the given value is a number
 			if (isNumber(a[i])) {
-				b[i] = parseFloat(a[i].toFixed(this.precision));
+				b[i] = parseFloat(parseFloat(a[i]).toFixed(this.precision));
 			} else {
 				b[i] = a[i];
 			}
 		}
-		
+
 		return b;
 	}
-	
+
 	/**
 	 * Transform a bounds array to a range array the following array : array(0,
 	 * 0.75, 1.5, 2.25, 3); becomes : array('0-0.75', '0.75-1.5', '1.5-2.25',
 	 * '2.25-3');
 	 */
 	this.setRanges = function() {
-	
+
 		this.ranges = Array(); // init empty array to prevent bug when calling classification after another with less items (sample getQuantile(6) and getQuantile(4))
-		
-		for (i = 0; i < (this.bounds.length - 1); i++) {
+
+		for (var i = 0; i < (this.bounds.length - 1); i++) {
 			this.ranges[i] = this.bounds[i] + this.separator + this.bounds[i + 1];
 		}
 	};
 
 	/** return min value */
-	this.min = function() {
-		
+	this.min = function(exclude = []) {
+
 		if (this._nodata())
 			return;
-		
-		this.stat_min = Math.min.apply(null, this.serie);
-		
+
+		if(!exclude.includes(this.serie[0])) this.stat_min = this.serie[0];
+		else this.stat_min = 999999999999;
+
+
+		for (var i = 0; i < this.pop(); i++) {
+			if (this.serie[i] < this.stat_min && !exclude.includes(this.serie[i])) {
+				this.stat_min = this.serie[i];
+			}
+		}
+
 		return this.stat_min;
 	};
 
 	/** return max value */
-	this.max = function() {
-		
-		this.stat_max = Math.max.apply(null, this.serie);
-		
+	this.max = function(exclude = []) {
+
+		if (this._nodata())
+			return;
+
+		if(!exclude.includes(this.serie[0])) this.stat_max = this.serie[0];
+		else this.stat_max = -999999999999;
+
+		for (var i = 0; i < this.pop(); i++) {
+			if (this.serie[i] > this.stat_max && !exclude.includes(this.serie[i])) {
+				this.stat_max = this.serie[i];
+			}
+		}
+
 		return this.stat_max;
 	};
 
 	/** return sum value */
 	this.sum = function() {
-		
+
 		if (this._nodata())
 			return;
-		
+
 		if (this.stat_sum  == null) {
-			
+
 			this.stat_sum = 0;
-			for (i = 0; i < this.pop(); i++) {
+			for (var i = 0; i < this.pop(); i++) {
 				this.stat_sum += parseFloat(this.serie[i]);
 			}
-			
+
 		}
-		
+
 		return this.stat_sum;
 	};
 
 	/** return population number */
 	this.pop = function() {
-		
+
 		if (this._nodata())
 			return;
-		
+
 		if (this.stat_pop  == null) {
-			
+
 			this.stat_pop = this.serie.length;
-			
+
 		}
-		
+
 		return this.stat_pop;
 	};
 
 	/** return mean value */
 	this.mean = function() {
-		
+
 		if (this._nodata())
 			return;
 
 		if (this.stat_mean  == null) {
-			
+
 			this.stat_mean = parseFloat(this.sum() / this.pop());
-			
+
 		}
-		
+
 		return this.stat_mean;
 	};
 
 	/** return median value */
 	this.median = function() {
-		
+
 		if (this._nodata())
 			return;
-		
+
 		if (this.stat_median  == null) {
-			
+
 			this.stat_median = 0;
 			var tmp = this.sorted();
-			
+
 			// serie pop is odd
 			if (tmp.length % 2) {
 				this.stat_median = parseFloat(tmp[(Math.ceil(tmp.length / 2) - 1)]);
-				
+
 			// serie pop is even
 			} else {
 				this.stat_median = ( parseFloat(tmp[((tmp.length / 2) - 1)]) + parseFloat(tmp[(tmp.length / 2)]) ) / 2;
 			}
-			
+
 		}
-		
+
 		return this.stat_median;
 	};
 
 	/** return variance value */
 	this.variance = function() {
-		
-		round = (typeof round === "undefined") ? true : false;
-		
+
+		var round = (typeof round === "undefined") ? true : false;
+
 		if (this._nodata())
 			return;
-		
+
 		if (this.stat_variance  == null) {
 
-			var tmp = 0;
+			var tmp = 0, serie_mean = this.mean();
 			for (var i = 0; i < this.pop(); i++) {
-				tmp += Math.pow( (this.serie[i] - this.mean()), 2 );
+				tmp += Math.pow( (this.serie[i] - serie_mean), 2 );
 			}
 
-			this.stat_variance =  tmp /	this.pop();
-			
+			this.stat_variance =  tmp / this.pop();
+
 			if(round == true) {
 				this.stat_variance = Math.round(this.stat_variance * Math.pow(10,this.roundlength) )/ Math.pow(10,this.roundlength);
 			}
-			
+
 		}
-		
+
 		return this.stat_variance;
 	};
-	
+
 	/** return standard deviation value */
 	this.stddev = function(round) {
-		
-		round = (typeof round === "undefined") ? true : false;
-		
+
+		var round = (typeof round === "undefined") ? true : false;
+
 		if (this._nodata())
 			return;
-		
+
 		if (this.stat_stddev  == null) {
-			
+
 			this.stat_stddev = Math.sqrt(this.variance());
-			
+
 			if(round == true) {
 				this.stat_stddev = Math.round(this.stat_stddev * Math.pow(10,this.roundlength) )/ Math.pow(10,this.roundlength);
 			}
-			
+
 		}
-		
+
 		return this.stat_stddev;
 	};
-	
+
 	/** coefficient of variation - measure of dispersion */
 	this.cov = function(round) {
-		
-		round = (typeof round === "undefined") ? true : false;
-		
+
+		var round = (typeof round === "undefined") ? true : false;
+
 		if (this._nodata())
 			return;
-		
+
 		if (this.stat_cov  == null) {
-			
+
 			this.stat_cov = this.stddev() / this.mean();
-			
+
 			if(round == true) {
 				this.stat_cov = Math.round(this.stat_cov * Math.pow(10,this.roundlength) )/ Math.pow(10,this.roundlength);
 			}
-			
+
 		}
-		
+
 		return this.stat_cov;
 	};
-	
+
 	/** reset all attributes after setting a new serie */
 	this.resetStatistics = function() {
 	    this.stat_sorted    = null;
@@ -433,34 +462,63 @@ var geostats = function(a) {
 	    this.stat_stddev    = null;
 	    this.stat_cov       = null;
 	}
-	
+
 	/** data test */
 	this._nodata = function() {
 		if (this.serie.length == 0) {
-			
+
 			if(this.silent) this.log("[silent mode] Error. You should first enter a serie!", true);
-			else alert("Error. You should first enter a serie!");
+			else throw new TypeError("Error. You should first enter a serie!");
 			return 1;
 		} else
 			return 0;
-		
+
+	};
+
+	/** data test */
+	this._classificationCheck = function(nbClass) {
+
+		if(nbClass >= this.pop()) {
+			var errnum ='Error. ' + nbClass + ' classes are defined for only ' + this.pop() + ' values in serie ! For the current serie, no more than ' + (this.pop() - 1 ) + ' classes can be defined.';
+
+			if(this.silent) this.log(errnum, true);
+			else {
+				alert(errnum);
+				throw new TypeError(errnum);
+			}
+
+		}
+
 	};
-	
+
+	/** ensure nbClass is an integer */
+	this._nbClassInt = function(nbClass) {
+
+		var nbclassTmp = parseInt(nbClass, 10);
+		if (isNaN(nbclassTmp)) {
+			if(this.silent) this.log("[silent mode] '" + nbclassTmp + "' is not a valid integer. Enable to set class number.", true);
+			else throw new TypeError("'" + nbclassTmp + "' is not a valid integer. Enable to set class number.");
+		} else {
+			return nbclassTmp;
+		}
+
+	};
+
 	/** check if the serie contains negative value */
 	this._hasNegativeValue = function() {
-		
-		for (i = 0; i < this.serie.length; i++) {
+
+		for (var i = 0; i < this.serie.length; i++) {
 	    	if(this.serie[i] < 0)
 	    		return true;
 	    }
 
 		return false;
 	};
-	
+
 	/** check if the serie contains zero value */
 	this._hasZeroValue = function() {
-		
-		for (i = 0; i < this.serie.length; i++) {
+
+		for (var i = 0; i < this.serie.length; i++) {
 	    	if(parseFloat(this.serie[i]) === 0)
 	    		return true;
 	    }
@@ -470,9 +528,9 @@ var geostats = function(a) {
 
 	/** return sorted values (as array) */
 	this.sorted = function() {
-		
+
 		if (this.stat_sorted  == null) {
-			
+
 			if(this.is_uniqueValues == false) {
 				this.stat_sorted = this.serie.sort(function(a, b) {
 					return a - b;
@@ -486,33 +544,33 @@ var geostats = function(a) {
 				})
 			}
 		}
-		
+
 		return this.stat_sorted;
-		
+
 	};
 
 	/** return all info */
 	this.info = function() {
-		
+
 		if (this._nodata())
 			return;
-		
+
 		var content = '';
 		content += _t('Population') + ' : ' + this.pop() + ' - [' + _t('Min')
 				+ ' : ' + this.min() + ' | ' + _t('Max') + ' : ' + this.max()
 				+ ']' + "\n";
 		content += _t('Mean') + ' : ' + this.mean() + ' - ' + _t('Median')	+ ' : ' + this.median() + "\n";
-		content += _t('Variance') + ' : ' + this.variance() + ' - ' + _t('Standard deviation')	+ ' : ' + this.stddev()  
+		content += _t('Variance') + ' : ' + this.variance() + ' - ' + _t('Standard deviation')	+ ' : ' + this.stddev()
 				+ ' - ' + _t('Coefficient of variation')	+ ' : ' + this.cov() + "\n";
 
 		return content;
 	};
-	
+
 	/**
 	 * Set Manual classification Return an array with bounds : ie array(0,
 	 * 0.75, 1.5, 2.25, 3);
 	 * Set ranges and prepare data for displaying legend
-	 * 
+	 *
 	 */
 	this.setClassManually = function(array) {
 
@@ -521,13 +579,13 @@ var geostats = function(a) {
 
 	    if(array[0] !== this.min() || array[array.length-1] !== this.max()) {
 	    	if(this.silent) this.log("[silent mode] " + t('Given bounds may not be correct! please check your input.\nMin value : ' + this.min() + ' / Max value : ' + this.max()), true);
-			else alert(_t('Given bounds may not be correct! please check your input.\nMin value : ' + this.min() + ' / Max value : ' + this.max()));
-	    	return; 
+			else throw new TypeError(_t('Given bounds may not be correct! please check your input.\nMin value : ' + this.min() + ' / Max value : ' + this.max()));
+	    	return;
 	    }
 
 	    this.setBounds(array);
 	    this.setRanges();
-	    
+
 	    // we specify the classification method
 	    this.method = _t('manual classification') + ' (' + (array.length -1) + ' ' + _t('classes') + ')';
 
@@ -540,17 +598,19 @@ var geostats = function(a) {
 	 */
 	this.getClassEqInterval = function(nbClass, forceMin, forceMax) {
 
+		var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
+
 		if (this._nodata())
 	        return;
 
 		var tmpMin = (typeof forceMin === "undefined") ? this.min() : forceMin;
 		var tmpMax = (typeof forceMax === "undefined") ? this.max() : forceMax;
-		
+
 	    var a = Array();
 	    var val = tmpMin;
 	    var interval = (tmpMax - tmpMin) / nbClass;
 
-	    for (i = 0; i <= nbClass; i++) {
+	    for (var i = 0; i <= nbClass; i++) {
 	        a[i] = val;
 	        val += interval;
 	    }
@@ -560,15 +620,18 @@ var geostats = function(a) {
 
 	    this.setBounds(a);
 	    this.setRanges();
-	    
+
 	    // we specify the classification method
 	    this.method = _t('eq. intervals') + ' (' + nbClass + ' ' + _t('classes') + ')';
 
 	    return this.bounds;
 	};
-	
+
 
 	this.getQuantiles = function(nbClass) {
+
+		var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
+
 		var tmp = this.sorted();
 		var quantiles = [];
 
@@ -587,9 +650,13 @@ var geostats = function(a) {
 	 */
 	this.getClassQuantile = function(nbClass) {
 
+		var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
+
 		if (this._nodata())
 			return;
 
+		this._classificationCheck(nbClass); // be sure number of classes is valid
+
 		var tmp = this.sorted();
 		var bounds = this.getQuantiles(nbClass);
 		bounds.unshift(tmp[0]);
@@ -606,7 +673,7 @@ var geostats = function(a) {
 		return this.bounds;
 
 	};
-	
+
 	/**
 	 * Standard Deviation classification
 	 * Return an array with bounds : ie array(0,
@@ -614,180 +681,194 @@ var geostats = function(a) {
 	 */
 	this.getClassStdDeviation = function(nbClass, matchBounds) {
 
+		var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
+
 		if (this._nodata())
 	        return;
 
 	    var tmpMax = this.max();
-	    var tmpMin = this.min();
-	    
+		var tmpMin = this.min();
+		var tmpStdDev = this.stddev();
+		var tmpMean = this.mean();
+
 	    var a = Array();
-	    
+
 	    // number of classes is odd
 	    if(nbClass % 2 == 1) {
 
 	    	// Euclidean division to get the inferior bound
 	    	var infBound = Math.floor(nbClass / 2);
-	    	
+
 	    	var supBound = infBound + 1;
-	    	
+
 	    	// we set the central bounds
-	    	a[infBound] = this.mean() - ( this.stddev() / 2);
-	    	a[supBound] = this.mean() + ( this.stddev() / 2);
-	    	
+	    	a[infBound] = tmpMean - (tmpStdDev / 2);
+	    	a[supBound] = tmpMean + (tmpStdDev / 2);
+
 	    	// Values < to infBound, except first one
-	    	for (i = infBound - 1; i > 0; i--) {
-	    		var val = a[i+1] - this.stddev();
+	    	for (var i = infBound - 1; i > 0; i--) {
+	    		var val = a[i+1] - tmpStdDev;
 		        a[i] = val;
 		    }
-	    	
+
 	    	// Values > to supBound, except last one
-	    	for (i = supBound + 1; i < nbClass; i++) {
-	    		var val = a[i-1] + this.stddev();
+	    	for (var i = supBound + 1; i < nbClass; i++) {
+	    		var val = a[i-1] + tmpStdDev;
 		        a[i] = val;
 		    }
-	    	
+
 	    	// number of classes is even
 	    } else {
-	    	
+
 	    	var meanBound = nbClass / 2;
-	    	
+
 	    	// we get the mean value
-	    	a[meanBound] = this.mean();
-	    	
+	    	a[meanBound] = tmpMean;
+
 	    	// Values < to the mean, except first one
-	    	for (i = meanBound - 1; i > 0; i--) {
-	    		var val = a[i+1] - this.stddev();
+	    	for (var i = meanBound - 1; i > 0; i--) {
+	    		var val = a[i+1] - tmpStdDev;
 		        a[i] = val;
 		    }
-	    	
+
 	    	// Values > to the mean, except last one
-	    	for (i = meanBound + 1; i < nbClass; i++) {
-	    		var val = a[i-1] + this.stddev();
+	    	for (var i = meanBound + 1; i < nbClass; i++) {
+	    		var val = a[i-1] + tmpStdDev;
 		        a[i] = val;
 		    }
 	    }
-	    
-	    
+
+
 	    // we finally set the first value
-	    // do we excatly match min value or not ? 
-	    a[0] = (typeof matchBounds === "undefined") ? a[1]-this.stddev() : this.min();
-    	
+	    // do we excatly match min value or not ?
+	    a[0] = (typeof matchBounds === "undefined") ? a[1]- tmpStdDev : tmpMin;
+
     	// we finally set the last value
-	    // do we excatly match max value or not ? 
-    	a[nbClass] = (typeof matchBounds === "undefined") ? a[nbClass-1]+this.stddev() : this.max();
+	    // do we excatly match max value or not ?
+    	a[nbClass] = (typeof matchBounds === "undefined") ? a[nbClass-1] + tmpStdDev : tmpMax;
 
 	    this.setBounds(a);
 	    this.setRanges();
-	    
+
 	    // we specify the classification method
-	    this.method = _t('std deviation') + ' (' + nbClass + ' ' + _t('classes')+ ')'; 
-	    
+	    this.method = _t('std deviation') + ' (' + nbClass + ' ' + _t('classes')+ ')';
+
 	    return this.bounds;
 	};
-	
-	
+
+
 	/**
-	 * Geometric Progression classification 
+	 * Geometric Progression classification
 	 * http://en.wikipedia.org/wiki/Geometric_progression
 	 * Return an array with bounds : ie array(0,
 	 * 0.75, 1.5, 2.25, 3);
 	 */
 	this.getClassGeometricProgression = function(nbClass) {
 
+		var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
+
 		if (this._nodata())
 	        return;
 
 	    if(this._hasNegativeValue() || this._hasZeroValue()) {
 	    	if(this.silent) this.log("[silent mode] " + _t('geometric progression can\'t be applied with a serie containing negative or zero values.'), true);
-			else alert(_t('geometric progression can\'t be applied with a serie containing negative or zero values.'));
+			else throw new TypeError(_t('geometric progression can\'t be applied with a serie containing negative or zero values.'));
 	    	return;
 	    }
-	    
+
 	    var a = Array();
 	    var tmpMin = this.min();
 	    var tmpMax = this.max();
-	    
+
 	    var logMax = Math.log(tmpMax) / Math.LN10; // max decimal logarithm (or base 10)
 	    var logMin = Math.log(tmpMin) / Math.LN10;; // min decimal logarithm (or base 10)
-	    
+
 	    var interval = (logMax - logMin) / nbClass;
-	    
+
 	    // we compute log bounds
-	    for (i = 0; i < nbClass; i++) {
+	    for (var i = 0; i < nbClass; i++) {
 	    	if(i == 0) {
 	    		a[i] = logMin;
 	    	} else {
 	    		a[i] = a[i-1] + interval;
 	    	}
 	    }
-	    
+
 	    // we compute antilog
 	    a = a.map(function(x) { return Math.pow(10, x); });
-	    
+
 	    // and we finally add max value
 	    a.push(this.max());
-	    
+
 	    this.setBounds(a);
 	    this.setRanges();
-	    
+
 	    // we specify the classification method
 	    this.method = _t('geometric progression') + ' (' + nbClass + ' ' + _t('classes') + ')';
 
 	    return this.bounds;
 	};
-	
+
 	/**
-	 * Arithmetic Progression classification 
+	 * Arithmetic Progression classification
 	 * http://en.wikipedia.org/wiki/Arithmetic_progression
 	 * Return an array with bounds : ie array(0,
 	 * 0.75, 1.5, 2.25, 3);
 	 */
 	this.getClassArithmeticProgression = function(nbClass) {
 
+		var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
+
 		if (this._nodata())
 	        return;
-	    
+
 	    var denominator = 0;
-	    
+
 	    // we compute the (french) "Raison"
-	    for (i = 1; i <= nbClass; i++) {
+	    for (var i = 1; i <= nbClass; i++) {
 	        denominator += i;
 	    }
 
 	    var a = Array();
 	    var tmpMin = this.min();
 	    var tmpMax = this.max();
-	    
+
 	    var interval = (tmpMax - tmpMin) / denominator;
 
-	    for (i = 0; i <= nbClass; i++) {
+	    for (var i = 0; i <= nbClass; i++) {
 	    	if(i == 0) {
 	    		a[i] = tmpMin;
-	    	} else {
+			} else if(i == nbClass) {
+				a[i] = tmpMax;
+			} else {
 	    		a[i] = a[i-1] + (i * interval);
 	    	}
 	    }
 
 	    this.setBounds(a);
 	    this.setRanges();
-	    
+
 	    // we specify the classification method
 	    this.method = _t('arithmetic progression') + ' (' + nbClass + ' ' + _t('classes') + ')';
 
 	    return this.bounds;
 	};
-	
+
 	/**
 	 * Credits : Doug Curl (javascript) and Daniel J Lewis (python implementation)
 	 * http://www.arcgis.com/home/item.html?id=0b633ff2f40d412995b8be377211c47b
 	 * http://danieljlewis.org/2010/06/07/jenks-natural-breaks-algorithm-in-python/
 	 */
-	this.getClassJenks = function(nbClass) {
-	
+	this.getClassJenks2 = function(nbClass) {
+
+		var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
+
 		if (this._nodata())
 			return;
-		
-		dataList = this.sorted();
+
+		this._classificationCheck(nbClass); // be sure number of classes is valid
+
+		var dataList = this.sorted();
 
 		// now iterate through the datalist:
 		// determine mat1 and mat2
@@ -859,7 +940,7 @@ var geostats = function(a) {
 		var kclass = []
 
 		// fill the kclass (classification) array with zeros:
-		for (i = 0; i <= nbClass; i++) {
+		for (var i = 0; i <= nbClass; i++) {
 			kclass.push(0);
 		}
 
@@ -888,43 +969,186 @@ var geostats = function(a) {
 		this.setBounds(kclass);
 		this.setRanges();
 
-		
+
+		this.method = _t('Jenks2') + ' (' + nbClass + ' ' + _t('classes') + ')';
+
+		return this.bounds; //array of breaks
+	}
+
+	/**
+	 * Credits from simple-statistics library
+	 * https://github.com/simple-statistics/simple-statistics
+	 * https://gist.githubusercontent.com/tmcw/4969184/raw/cfd9572d00db6bcdc34f07b088738fc3a47846b4/simple_statistics.js
+	 */
+	this.getClassJenks = function(nbClass) {
+
+		var nbClass = this._nbClassInt(nbClass); // ensure nbClass is an integer
+
+		if (this._nodata())
+			return;
+
+		this._classificationCheck(nbClass); // be sure number of classes is valid
+
+		var dataList = this.sorted();
+
+		// Compute the matrices required for Jenks breaks. These matrices
+		// can be used for any classing of data with `classes <= n_classes`
+		var jenksMatrices = function(data, n_classes) {
+
+			// in the original implementation, these matrices are referred to
+			// as `LC` and `OP`
+			//
+			// * lower_class_limits (LC): optimal lower class limits
+			// * variance_combinations (OP): optimal variance combinations for all classes
+			var lower_class_limits = [],
+				variance_combinations = [],
+				// loop counters
+				i, j,
+				// the variance, as computed at each step in the calculation
+				variance = 0;
+
+			// Initialize and fill each matrix with zeroes
+			for (var i = 0; i < data.length + 1; i++) {
+				var tmp1 = [], tmp2 = [];
+				for (var j = 0; j < n_classes + 1; j++) {
+					tmp1.push(0);
+					tmp2.push(0);
+				}
+				lower_class_limits.push(tmp1);
+				variance_combinations.push(tmp2);
+			}
+
+			for (var i = 1; i < n_classes + 1; i++) {
+				lower_class_limits[1][i] = 1;
+				variance_combinations[1][i] = 0;
+				// in the original implementation, 9999999 is used but
+				// since Javascript has `Infinity`, we use that.
+				for (var j = 2; j < data.length + 1; j++) {
+					variance_combinations[j][i] = Infinity;
+				}
+			}
+
+			for (var l = 2; l < data.length + 1; l++) {
+
+				// `SZ` originally. this is the sum of the values seen thus
+				// far when calculating variance.
+				var sum = 0,
+					// `ZSQ` originally. the sum of squares of values seen
+					// thus far
+					sum_squares = 0,
+					// `WT` originally. This is the number of
+					w = 0,
+					// `IV` originally
+					i4 = 0;
+
+				// in several instances, you could say `Math.pow(x, 2)`
+				// instead of `x * x`, but this is slower in some browsers
+				// introduces an unnecessary concept.
+				for (var m = 1; m < l + 1; m++) {
+
+					// `III` originally
+					var lower_class_limit = l - m + 1,
+						val = data[lower_class_limit - 1];
+
+					// here we're estimating variance for each potential classing
+					// of the data, for each potential number of classes. `w`
+					// is the number of data points considered so far.
+					w++;
+
+					// increase the current sum and sum-of-squares
+					sum += val;
+					sum_squares += val * val;
+
+					// the variance at this point in the sequence is the difference
+					// between the sum of squares and the total x 2, over the number
+					// of samples.
+					variance = sum_squares - (sum * sum) / w;
+
+					i4 = lower_class_limit - 1;
+
+					if (i4 !== 0) {
+						for (var j = 2; j < n_classes + 1; j++) {
+							if (variance_combinations[l][j] >=
+								(variance + variance_combinations[i4][j - 1])) {
+								lower_class_limits[l][j] = lower_class_limit;
+								variance_combinations[l][j] = variance +
+									variance_combinations[i4][j - 1];
+							}
+						}
+					}
+				}
+
+				lower_class_limits[l][1] = 1;
+				variance_combinations[l][1] = variance;
+			}
+
+			return {
+				lower_class_limits: lower_class_limits,
+				variance_combinations: variance_combinations
+			};
+		};
+
+        // get our basic matrices
+        var matrices = jenksMatrices(dataList, nbClass),
+            // we only need lower class limits here
+            lower_class_limits = matrices.lower_class_limits,
+            k = dataList.length - 1,
+            kclass = [],
+            countNum = nbClass;
+
+        // the calculation of classes will never include the upper and
+        // lower bounds, so we need to explicitly set them
+        kclass[nbClass] = dataList[dataList.length - 1];
+        kclass[0] = dataList[0];
+
+        // the lower_class_limits matrix is used as indexes into itself
+        // here: the `k` variable is reused in each iteration.
+        while (countNum > 1) {
+            kclass[countNum - 1] = dataList[lower_class_limits[k][countNum] - 2];
+            k = lower_class_limits[k][countNum] - 1;
+            countNum--;
+        }
+
+		this.setBounds(kclass);
+		this.setRanges();
+
+
 		this.method = _t('Jenks') + ' (' + nbClass + ' ' + _t('classes') + ')';
-		
+
 		return this.bounds; //array of breaks
 	}
-	
-	
+
+
 	/**
-	 * Quantile classification Return an array with bounds : ie array(0, 0.75,
+	 * Unique classification Return as many entries as unique values : ie array('blue', 'red', yellow')
 	 * 1.5, 2.25, 3);
 	 */
 	this.getClassUniqueValues = function() {
 
 		if (this._nodata())
 			return;
-		
+
 		this.is_uniqueValues = true;
-		
+
 		var tmp = this.sorted(); // display in alphabetical order
 
 		var a = Array();
 
-		for (i = 0; i < this.pop(); i++) {
+		for (var i = 0; i < this.pop(); i++) {
 			if(a.indexOf(tmp[i]) === -1)
 				a.push(tmp[i]);
 		}
-		
+
 		this.bounds = a;
-		
+
 		// we specify the classification method
 		this.method = _t('unique values');
-		
+
 		return a;
 
 	};
-	
-	
+
+
 	/**
 	 * Return the class of a given value.
 	 * For example value : 6
@@ -933,12 +1157,14 @@ var geostats = function(a) {
 	 */
 	this.getClass = function(value) {
 
-		for(i = 0; i < this.bounds.length; i++) {
-			
-			
+		for (var i = 0; i < this.bounds.length; i++) {
+
 			if(this.is_uniqueValues == true) {
-				if(value == this.bounds[i])
+
+				if(value == this.bounds[i]) {
+					// console.log(value + ' - ' + this.bounds[i] + ' returned value : ' + i);
 					return i;
+				}
 			} else {
 				// parseFloat() is necessary
 				if(parseFloat(value) <= this.bounds[i + 1]) {
@@ -946,9 +1172,9 @@ var geostats = function(a) {
 				}
 			}
 		}
-		
+
 		return _t("Unable to get value's class.");
-		
+
 	};
 
 	/**
@@ -956,120 +1182,120 @@ var geostats = function(a) {
 	 * '2.25-3');
 	 */
 	this.getRanges = function() {
-		
+
 		return this.ranges;
-		
+
 	};
 
 	/**
 	 * Returns the number/index of this.ranges that value falls into
 	 */
 	this.getRangeNum = function(value) {
-		
+
 		var bounds, i;
 
-		for (i = 0; i < this.ranges.length; i++) {
+		for (var i = 0; i < this.ranges.length; i++) {
 			bounds = this.ranges[i].split(/ - /);
 			if (value <= parseFloat(bounds[1])) {
 				return i;
 			}
 		}
 	}
-	
+
 	/*
-	 * Compute inner ranges based on serie. 
-	 * Produce discontinous ranges used for legend - return an array similar to : 
+	 * Compute inner ranges based on serie.
+	 * Produce discontinous ranges used for legend - return an array similar to :
 	 * array('0.00-0.74', '0.98-1.52', '1.78-2.25', '2.99-3.14');
 	 * If inner ranges already computed, return array values.
 	 */
 	this.getInnerRanges = function() {
-		
+
 		// if already computed, we return the result
 		if(this.inner_ranges != null)
 			return this.inner_ranges;
 
-		
+
 		var a = new Array();
 		var tmp = this.sorted();
-		
+
 		var cnt = 1; // bounds array counter
-		
-		for (i = 0; i < tmp.length; i++) {
-			
+
+		for (var i = 0; i < tmp.length; i++) {
+
 			if(i == 0) var range_firstvalue = tmp[i]; // we init first range value
-			
+
 			if(parseFloat(tmp[i]) > parseFloat(this.bounds[cnt])) {
-				
+
 				a[cnt - 1] = '' + range_firstvalue + this.separator + tmp[i-1];
-				
+
 				var range_firstvalue =  tmp[i];
-				
+
 				cnt++;
 
 			}
-			
+
 			// we reach the last range, we finally complete manually
 			// and return the array
 			if(cnt == (this.bounds.length - 1)) {
 				// we set the last value
 				a[cnt - 1] = '' + range_firstvalue + this.separator + tmp[tmp.length-1];
-				
+
 				this.inner_ranges = a;
 				return this.inner_ranges;
 			}
-			
+
 
 		}
-		
+
 	};
-	
+
 	this.getSortedlist = function() {
-		
+
 		return this.sorted().join(', ');
-		
+
 	};
-	
+
 	/**
 	 * Return an html legend
 	 * colors : specify an array of color (hexadecimal values)
 	 * legend :  specify a text input for the legend. By default, just displays 'legend'
 	 * counter : if not null, display counter value
 	 * callback : if not null, callback function applied on legend boundaries
-	 * mode : 	null, 'default', 'distinct', 'discontinuous' : 
+	 * mode : 	null, 'default', 'distinct', 'discontinuous' :
 	 * 			- if mode is null, will display legend as 'default mode'
 	 * 			- 'default' : displays ranges like in ranges array (continuous values), sample :  29.26 - 378.80 / 378.80 - 2762.25 /  2762.25 - 6884.84
-	 * 			- 'distinct' : Add + 1 according to decimal precision to distinguish classes (discrete values), sample :  29.26 - 378.80 / 378.81 - 2762.25 /  2762.26 - 6884.84 
+	 * 			- 'distinct' : Add + 1 according to decimal precision to distinguish classes (discrete values), sample :  29.26 - 378.80 / 378.81 - 2762.25 /  2762.26 - 6884.84
 	 * 			- 'discontinuous' : indicates the range of data actually falling in each class , sample :  29.26 - 225.43 / 852.12 - 2762.20 /  3001.25 - 6884.84 / not implemented yet
 	 * order : 	null, 'ASC', 'DESC'
 	 */
 	this.getHtmlLegend = function(colors, legend, counter, callback, mode, order) {
-		
+
 		var cnt= '';
 		var elements = new Array();
-		
+
 		this.doCount(); // we do count, even if not displayed
-		
+
 		if(colors != null) {
 			ccolors = colors;
 		}
 		else {
 			ccolors = this.colors;
 		}
-		
+
 		if(legend != null) {
 			lg = legend;
 		}
 		else {
 			lg =  'Legend';
 		}
-		
+
 		if(counter != null) {
 			getcounter = true;
 		}
 		else {
 			getcounter = false;
 		}
-		
+
 		if(callback != null) {
 			fn = callback;
 		}
@@ -1084,34 +1310,34 @@ var geostats = function(a) {
 			// check if some classes are not populated / equivalent of in_array function
 			if(this.counter.indexOf(0) !== -1) {
 		    	if(this.silent) this.log("[silent mode] " + _t("Geostats cannot apply 'discontinuous' mode to the getHtmlLegend() method because some classes are not populated.\nPlease switch to 'default' or 'distinct' modes. Exit!"), true);
-				else alert(_t("Geostats cannot apply 'discontinuous' mode to the getHtmlLegend() method because some classes are not populated.\nPlease switch to 'default' or 'distinct' modes. Exit!"));
+				else throw new TypeError(_t("Geostats cannot apply 'discontinuous' mode to the getHtmlLegend() method because some classes are not populated.\nPlease switch to 'default' or 'distinct' modes. Exit!"));
 				return;
 			}
 
 		}
 		if(order !== 'DESC') order = 'ASC';
-		
+
 		if(ccolors.length < this.ranges.length) {
 			if(this.silent) this.log("[silent mode] " + _t('The number of colors should fit the number of ranges. Exit!'), true);
-			else alert(_t('The number of colors should fit the number of ranges. Exit!'));
+			else throw new TypeError(_t('The number of colors should fit the number of ranges. Exit!'));
 			return;
 		}
-		
+
 		if(this.is_uniqueValues == false) {
-			
-			for (i = 0; i < (this.ranges.length); i++) {
+
+			for (var i = 0; i < (this.ranges.length); i++) {
 				if(getcounter===true) {
 					cnt = ' <span class="geostats-legend-counter">(' + this.counter[i] + ')</span>';
 				}
 				//console.log("Ranges : " + this.ranges[i]);
-				
-				// default mode 
+
+				// default mode
 				var tmp = this.ranges[i].split(this.separator);
-					
+
 				var start_value = parseFloat(tmp[0]).toFixed(this.precision);
 				var end_value = parseFloat(tmp[1]).toFixed(this.precision);
-					
-				
+
+
 				// if mode == 'distinct' and we are not working on the first value
 				if(mode == 'distinct' && i != 0) {
 
@@ -1122,34 +1348,34 @@ var geostats = function(a) {
 					} else {
 
 						start_value = parseFloat(start_value) + (1 / Math.pow(10,this.precision));
-						// strangely the formula above return sometimes long decimal values, 
+						// strangely the formula above return sometimes long decimal values,
 						// the following instruction fix it
 						start_value = parseFloat(start_value).toFixed(this.precision);
 					}
 				}
-				
+
 				// if mode == 'discontinuous'
 				if(mode == 'discontinuous') {
-										
+
 					var tmp = this.inner_ranges[i].split(this.separator);
 					// console.log("Ranges : " + this.inner_ranges[i]);
-					
+
 					var start_value = parseFloat(tmp[0]).toFixed(this.precision);
 					var end_value = parseFloat(tmp[1]).toFixed(this.precision);
-					
+
 				}
-				
+
 				// we apply callback function
 				var el = fn(start_value) + this.legendSeparator + fn(end_value);
-					
+
 				var block = '<div><div class="geostats-legend-block" style="background-color:' + ccolors[i] + '"></div> ' + el + cnt + '</div>';
 				elements.push(block);
 			}
-			
+
 		} else {
-			
+
 			// only if classification is done on unique values
-			for (i = 0; i < (this.bounds.length); i++) {
+			for (var i = 0; i < (this.bounds.length); i++) {
 				if(getcounter===true) {
 					cnt = ' <span class="geostats-legend-counter">(' + this.counter[i] + ')</span>';
 				}
@@ -1158,31 +1384,31 @@ var geostats = function(a) {
 
 				elements.push(block);
 			}
-			
+
 		}
-		
+
 		// do we reverse the return legend ?
-		if(order === 'DESC') elements.reverse(); 
-		
+		if(order === 'DESC') elements.reverse();
+
 		// finally we create HTML and return it
 		var content  = '<div class="geostats-legend"><div class="geostats-legend-title">' + _t(lg) + '</div>';
-		for (i = 0; i < (elements.length); i++) {
+		for (var i = 0; i < (elements.length); i++) {
 			content += elements[i];
 		}
 		content += '</div>';
-    
+
 		return content;
 	};
 
-	
-	
+
+
 	// object constructor
 	// At the end of script. If not setPrecision() method is not known
-	
+
 	// we create an object identifier for debugging
 	this.objectID = new Date().getUTCMilliseconds();
 	this.log('Creating new geostats object');
-	
+
 	if(typeof a !== 'undefined' && a.length > 0) {
 		this.serie = a;
 		this.setPrecision();
@@ -1191,9 +1417,10 @@ var geostats = function(a) {
 		this.serie = Array();
 
 	};
-	
+
 	// creating aliases on classification function for backward compatibility
 	this.getJenks = this.getClassJenks;
+	this.getJenks2 = this.getClassJenks2;
 	this.getGeometricProgression = this.getClassGeometricProgression;
 	this.getEqInterval = this.getClassEqInterval;
 	this.getQuantile = this.getClassQuantile;
@@ -1205,4 +1432,4 @@ var geostats = function(a) {
 
 
 return geostats;
-});
+});