x_ite 4.0.5 → 4.7.5

package/src/standard/Math/Algorithms/MergeSort.js

@@ -74,7 +74,7 @@ define (function ()
 		{
 			if (lo < hi)
 			{
-				var m = (lo + hi) >>> 1;
+				const m = (lo + hi) >>> 1;
 				this .mergeSort (lo, m);   // Recursion
 				this .mergeSort (m + 1, hi); // Recursion
 				this .merge (lo, m, hi);
@@ -82,7 +82,7 @@ define (function ()
 		},
 		merge: function (lo, m, hi)
 		{
-			var i, j, k;
+			let i, j, k;
 
 			i = 0, j = lo;
 			// Copy first half of array a to auxiliary array b.

package/src/standard/Math/Algorithms/PartialSort.js

@@ -0,0 +1,97 @@
+/* -*- Mode: JavaScript; coding: utf-8; tab-width: 3; indent-tabs-mode: tab; c-basic-offset: 3 -*-
+ *******************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright create3000, Scheffelstraße 31a, Leipzig, Germany 2011.
+ *
+ * All rights reserved. Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * The copyright notice above does not evidence any actual of intended
+ * publication of such source code, and is an unpublished work by create3000.
+ * This material contains CONFIDENTIAL INFORMATION that is the property of
+ * create3000.
+ *
+ * No permission is granted to copy, distribute, or create derivative works from
+ * the contents of this software, in whole or in part, without the prior written
+ * permission of create3000.
+ *
+ * NON-MILITARY USE ONLY
+ *
+ * All create3000 software are effectively free software with a non-military use
+ * restriction. It is free. Well commented source is provided. You may reuse the
+ * source in any way you please with the exception anything that uses it must be
+ * marked to indicate is contains 'non-military use only' components.
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2015, 2016 Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * This file is part of the X_ITE Project.
+ *
+ * X_ITE is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License version 3 only, as published by the
+ * Free Software Foundation.
+ *
+ * X_ITE is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License version 3 for more
+ * details (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version 3
+ * along with X_ITE.  If not, see <http://www.gnu.org/licenses/gpl.html> for a
+ * copy of the GPLv3 License.
+ *
+ * For Silvio, Joy and Adi.
+ *
+ ******************************************************************************/
+
+
+define (function ()
+{
+"use strict";
+
+	const shrinkFactor = 1 - Math .exp (-Math .PHI); // 0.801711847137793
+
+	function PartialSort (array, compare)
+	{
+		this .array = array;
+
+		if (compare)
+			this .compare = compare;
+	}
+
+	PartialSort .prototype =
+	{
+		compare: function (lhs, rhs)
+		{
+			return lhs < rhs;
+		},
+		sort: function (first, last)
+		{
+			if (last - first > 1)
+				this .partialsort (first, last);
+		},
+		partialsort: function (lo, hi)
+		{
+			let gap = this .last, i, last;
+
+			if (gap > 1)
+				gap = Math .floor (gap * shrinkFactor);
+
+			for (i = 0, last = this .last - gap; i < last; ++ i)
+			{
+				const j = i + gap;
+
+				if (this .compare (this .array [j], this .array [i]))
+				{
+					const t = array [i];
+					array [i] = array [j];
+					array [j] = t;
+				}
+			}
+		},
+	};
+
+	return PartialSort;
+});

package/src/standard/Math/Algorithms/QuickSort.js

@@ -54,7 +54,7 @@ define (function ()
 	function QuickSort (array, compare)
 	{
 		this .array = array;
-		
+
 		if (compare)
 			this .compare = compare;
 	}
@@ -72,14 +72,16 @@ define (function ()
 		},
 		quicksort: function (lo, hi)
 		{
-			var
+			let
 				i = lo,
-				j = hi,
+				j = hi;
+
+			const
 				array   = this .array,
 				compare = this .compare;
 
 			// Vergleichs­element x
-			var x = array [(lo + hi) >>> 1];
+			const x = array [(lo + hi) >>> 1];
 
 			for (;;)
 			{
@@ -89,8 +91,8 @@ define (function ()
 				if (i < j)
 				{
 					// Exchange
-					
-					var t = array [i];
+
+					const t = array [i];
 					array [i] = array [j];
 					array [j] = t;
 

package/src/standard/Math/Algorithms/SAT.js

@@ -51,7 +51,7 @@ define (function ()
 {
 "use strict";
 
-	var
+	const
 		extents1 = { min: 0, max: 0 },
 		extents2 = { min: 0, max: 0 };
 
@@ -64,10 +64,8 @@ define (function ()
 	{
 		// http://gamedev.stackexchange.com/questions/25397/obb-vs-obb-collision-detection
 
-		for (var i = 0, length = axes .length; i < length; ++ i)
+		for (const axis of axes)
 		{
-			var axis = axes [i];
-
 			project (points1, axis, extents1);
 			project (points2, axis, extents2);
 
@@ -86,15 +84,13 @@ define (function ()
 		extents .min = Number .POSITIVE_INFINITY;
 		extents .max = Number .NEGATIVE_INFINITY;
 
-		for (var i = 0, length = points .length; i < length; ++ i)
+		for (const point of points)
 		{
-			var point = points [i];
-
 			// Just dot it to get the min and max along this axis.
 			// NOTE: the axis must be normalized to get accurate projections to calculate the MTV, but if it is only needed to
 			// know whether it overlaps, every axis can be used.
 
-			var dotVal = point .dot (axis);
+			const dotVal = point .dot (axis);
 
 			if (dotVal < extents .min)
 				extents .min = dotVal;

package/src/standard/Math/Algorithms/eigendecomposition.js

@@ -51,37 +51,37 @@ define (function ()
 {
 "use strict";
 
+	const a = [ ]; // more scratch
+	const b = [ ]; // more scratch
+	const z = [ ]; // more scratch
+
 	// Calculate eigenvalues and eigenvectors.
 	// This is from SGI Inventor Matrix.cpp.
-	return function (matrix)
+	return function (matrix, result)
 	{
-		var
+		const
 			ORDER   = matrix .order,
-			values  = new Array (ORDER),
-			vectors = new Array (ORDER);
-
-		var sm;                // smallest entry
-		var theta;             // angle for Jacobi rotation
-		var c, s, t;           // cosine, sine, tangent of theta
-		var tau;               // sine / (1 + cos)
-		var h, g;              // two scrap values
-		var thresh;            // threshold below which no rotation done
-		var a = new Array (ORDER);
-		var b = new Array (ORDER); // more scratch
-		var z = new Array (ORDER); // more scratch
-		var p, q, i, j;
-		var SIZE = matrix .length;
+			values  = result .values,
+			vectors = result .vectors;
+
+		let
+			sm,                // smallest entry
+			theta,             // angle for Jacobi rotation
+			c, s, t,           // cosine, sine, tangent of theta
+			tau,               // sine / (1 + cos)
+			h, g,              // two scrap values
+			thresh,            // threshold below which no rotation done
+			p, q, i, j,
+			SIZE = matrix .length;
 
 		// initializations
-		for (i = 0; i < ORDER; ++i)
+		for (i = 0; i < ORDER; ++ i)
 		{
-			vectors [i] = new Array (ORDER);
-
-			a [i] = new Array (ORDER);
+			a [i] = a [i] || new Array (ORDER);
 			b [i] = values [i] = matrix .get1 (i, i);
 			z [i] = 0;
 
-			for (j = 0; j < ORDER; ++j)
+			for (j = 0; j < ORDER; ++ j)
 			{
 				vectors [i] [j] = (i === j) ? 1 : 0;
 				a [i] [j] = matrix .get1 (j, i);
@@ -90,13 +90,15 @@ define (function ()
 
 		// Why 50? I don't know--it's the way the folks who wrote the
 		// algorithm did it:
-		for (i = 0; i < 50; ++i)
+		for (i = 0; i < 50; ++ i)
 		{
 			sm = 0;
 
-			for (p = 0; p < ORDER - 1; ++p)
-				for (q = p+1; q < ORDER; ++q)
+			for (p = 0; p < ORDER - 1; ++ p)
+			{
+				for (q = p + 1; q < ORDER; ++ q)
 					sm += Math .abs (a [p] [q]);
+			}
 
 			if (sm === 0)
 				break;
@@ -105,9 +107,9 @@ define (function ()
 				0.2 * sm / SIZE :
 				0;
 
-			for (p = 0; p < ORDER - 1; ++p)
+			for (p = 0; p < ORDER - 1; ++ p)
 			{
-				for (q = p+1; q < ORDER; ++q)
+				for (q = p + 1; q < ORDER; ++ q)
 				{
 					g = 100 * Math .abs (a [p] [q]);
 
@@ -124,7 +126,9 @@ define (function ()
 						h = values [q] - values [p];
 
 						if (Math .abs (h) + g === Math .abs (h))
+						{
 							t = a [p] [q] / h;
+						}
 						else
 						{
 							theta = 0.5 * h / a [p] [q];
@@ -134,7 +138,7 @@ define (function ()
 						}
 						// End of computing tangent of rotation angle
 
-						c           = 1 / Math .sqrt (1 + t*t);
+						c           = 1 / Math .sqrt (1 + t * t);
 						s           = t * c;
 						tau         = s / (1 + c);
 						h           = t * a [p] [q];
@@ -144,7 +148,7 @@ define (function ()
 						values [q] += h;
 						a [p] [q]   = 0;
 
-						for (j = 0; j < p; ++j)
+						for (j = 0; j < p; ++ j)
 						{
 							g = a [j] [p];
 							h = a [j] [q];
@@ -152,7 +156,7 @@ define (function ()
 							a [j] [q] = h + s * (g - h * tau);
 						}
 
-						for (j = p+1; j < q; ++j)
+						for (j = p + 1; j < q; ++ j)
 						{
 							g = a [p] [j];
 							h = a [j] [q];
@@ -160,7 +164,7 @@ define (function ()
 							a [j] [q] = h + s * (g - h * tau);
 						}
 
-						for (j = q+1; j < ORDER; ++j)
+						for (j = q + 1; j < ORDER; ++ j)
 						{
 							g = a [p] [j];
 							h = a [q] [j];
@@ -168,7 +172,7 @@ define (function ()
 							a [q] [j] = h + s * (g - h * tau);
 						}
 
-						for (j = 0; j < ORDER; ++j)
+						for (j = 0; j < ORDER; ++ j)
 						{
 							g = vectors [j] [p];
 							h = vectors [j] [q];
@@ -179,13 +183,13 @@ define (function ()
 				}
 			}
 
-			for (p = 0; p < ORDER; ++p)
+			for (p = 0; p < ORDER; ++ p)
 			{
 				values [p] = b [p] += z [p];
 				z [p] = 0;
 			}
 		}
 
-		return { values: values, vectors: vectors };
+		return result;
 	};
 });

package/src/standard/Math/Geometry/Box2.js

@@ -55,28 +55,15 @@ function (Matrix3, Vector2)
 {
 "use strict";
 
-	var
-		x   = new Vector2 (0, 0),
-		y   = new Vector2 (0, 0),
-		min = new Vector2 (0, 0),
-		max = new Vector2 (0, 0),
-		p1  = new Vector2 (0, 0);
-
-	var
-		lhs_min = new Vector2 (0, 0),
-		lhs_max = new Vector2 (0, 0),
-		rhs_min = new Vector2 (0, 0),
-		rhs_max = new Vector2 (0, 0);
-
 	function Box2 (size, center)
 	{
 		switch (arguments .length)
 		{
 			case 0:
 			{
-				this .matrix = new Matrix3 (0.5, 0,   0,
-				                            0,   0.5, 0,
-				                            0,   0,   0);
+				this .matrix = new Matrix3 (0, 0, 0,
+				                            0, 0, 0,
+				                            0, 0, 0);
 				return;
 			}
 			case 2:
@@ -88,7 +75,7 @@ function (Matrix3, Vector2)
 			}
 			case 3:
 			{
-				var
+				const
 					min = arguments [0],
 					max = arguments [1],
 					sx  = (max .x - min .x) / 2,
@@ -109,7 +96,7 @@ function (Matrix3, Vector2)
 		constructor: Box2,
 		copy: function ()
 		{
-			var copy = Object .create (Box2 .prototype);
+			const copy = Object .create (Box2 .prototype);
 			copy .matrix = this .matrix .copy ();
 			return copy;
 		},
@@ -124,8 +111,8 @@ function (Matrix3, Vector2)
 		},
 		set: function (size, center)
 		{
-			var m = this .matrix;
-		
+			const m = this .matrix;
+
 			switch (arguments .length)
 			{
 				case 0:
@@ -143,11 +130,26 @@ function (Matrix3, Vector2)
 					m [6] = center .x;   m [7] = center .y;   m [8] = 1;
 					return this;
 				}
+				case 3:
+				{
+					const
+						min = arguments [0],
+						max = arguments [1],
+						sx  = (max .x - min .x) / 2,
+						sy  = (max .y - min .y) / 2,
+						cx  = (max .x + min .x) / 2,
+						cy  = (max .y + min .y) / 2;
+
+					this .matrix .set (sx, 0,  0,
+					                   0,  sy, 0,
+					                   cx, cy, 1);
+					return this;
+				}
 			}
 		},
 		setExtents: function (min, max)
 		{
-			var
+			const
 				m  = this .matrix,
 				sx = (max .x - min .x) / 2,
 				sy = (max .y - min .y) / 2,
@@ -163,19 +165,28 @@ function (Matrix3, Vector2)
 		{
 			return this .matrix [8] === 0;
 		},
-		add: function (box)
+		add: (function ()
 		{
-			if (this .isEmpty ())
-				return this .assign (box);
+			const
+				lhs_min = new Vector2 (0, 0),
+				lhs_max = new Vector2 (0, 0),
+				rhs_min = new Vector2 (0, 0),
+				rhs_max = new Vector2 (0, 0);
 
-			if (box .isEmpty ())
-				return this;
+			return function (box)
+			{
+				if (this .isEmpty ())
+					return this .assign (box);
 
-			this .getExtents (lhs_min, lhs_max);
-			box  .getExtents (rhs_min, rhs_max);
+				if (box .isEmpty ())
+					return this;
 
-			return this .assign (new Box2 (lhs_min .min (rhs_min), lhs_max .max (rhs_max), true));
-		},
+				this .getExtents (lhs_min, lhs_max);
+				box  .getExtents (rhs_min, rhs_max);
+
+				return this .set (lhs_min .min (rhs_min), lhs_max .max (rhs_max), true);
+			};
+		})(),
 		multLeft: function (matrix)
 		{
 			this .matrix .multLeft (matrix);
@@ -193,35 +204,47 @@ function (Matrix3, Vector2)
 			min .add (this .center);
 			max .add (this .center);
 		},
-		getAbsoluteExtents: function (min, max)
+		getAbsoluteExtents: (function ()
 		{
-		   var m = this .matrix;
+			const p1 = new Vector2 (0, 0);
 
-			x .set (m [0], m [1]);
-			y .set (m [3], m [4]);
+			return function (min, max)
+			{
+			   const
+					m = this .matrix,
+					x = m .xAxis,
+					y = m .yAxis;
 
-			p1 .assign (x) .add (y);
+				p1 .assign (x) .add (y);
 
-			var p2 = y .subtract (x);
+				const p2 = y .subtract (x);
 
-			min .assign (p1) .min (p2);
-			max .assign (p1) .max (p2);
+				min .assign (p1) .min (p2);
+				max .assign (p1) .max (p2);
 
-			p1 .negate ();
-			p2 .negate ();
+				p1 .negate ();
+				p2 .negate ();
 
-			min .min (p1, p2);
-			max .max (p1, p2);
-		},
-		intersectsPoint: function (point)
+				min .min (p1, p2);
+				max .max (p1, p2);
+			};
+		})(),
+		containsPoint: (function ()
 		{
-			this .getExtents (min, max);
+			const
+				min = new Vector2 (0, 0),
+				max = new Vector2 (0, 0);
 
-			return min .x <= point .x &&
-			       max .x >= point .x &&
-			       min .y <= point .y &&
-			       max .y >= point .y;
-		},
+			return function (point)
+			{
+				this .getExtents (min, max);
+
+				return min .x <= point .x &&
+				       max .x >= point .x &&
+				       min .y <= point .y &&
+				       max .y >= point .y;
+			};
+		})(),
 		toString: function ()
 		{
 			return this .size + ", " + this .center;
@@ -230,14 +253,19 @@ function (Matrix3, Vector2)
 
 	Object .defineProperty (Box2 .prototype, "size",
 	{
-		get: function ()
+		get: (function ()
 		{
-			var max = new Vector2 (0, 0);
-			
-			this .getAbsoluteExtents (min, max);
+			const
+				min = new Vector2 (0, 0),
+				max = new Vector2 (0, 0);
 
-			return max .subtract (min);
-		},
+			return function ()
+			{
+				this .getAbsoluteExtents (min, max);
+
+				return max .subtract (min);
+			};
+		})(),
 		enumerable: true,
 		configurable: false
 	});