x_ite 4.0.5 → 4.7.5

package/src/standard/Math/Numbers/Vector2.js

@@ -48,15 +48,14 @@
 
 
 define ([
-	"jquery",
 	"standard/Math/Algorithm",
 ],
-function ($, Algorithm)
+function (Algorithm)
 {
 "use strict";
 
 	function Vector2 (x, y)
-	{		
+	{
 		this .x = x;
 		this .y = y;
 	}
@@ -67,7 +66,7 @@ function ($, Algorithm)
 		length: 2,
 		copy: function ()
 		{
-			var copy = Object .create (Vector2 .prototype);
+			const copy = Object .create (Vector2 .prototype);
 			copy .x = this .x;
 			copy .y = this .y;
 			return copy;
@@ -133,9 +132,8 @@ function ($, Algorithm)
 		},
 		normalize: function ()
 		{
-			var length = Math .sqrt (this .x * this .x +
-			                         this .y * this .y);
-			
+			let length = Math .hypot (this .x, this .y);
+
 			if (length)
 			{
 				length = 1 / length;
@@ -153,51 +151,62 @@ function ($, Algorithm)
 		},
 		norm: function ()
 		{
-			return this .x * this .x +
-			       this .y * this .y;
+			const
+				x = this .x,
+				y = this .y;
+
+			return x * x +
+			       y * y;
 		},
 		abs: function ()
 		{
-			return Math .sqrt (this .x * this .x +
-			                   this .y * this .y);
+			return Math .hypot (this .x, this .y);
 		},
 		distance: function (vector)
 		{
-			var
-				x = this .x - vector .x,
-				y = this .y - vector .y;
-
-			return Math .sqrt (x * x +
-			                   y * y);
+			return Math .hypot (this .x - vector .x,
+			                    this .y - vector .y);
 		},
-		lerp: function (dest, t)
+		lerp: function (destination, t)
 		{
-			this .x = this .x + t * (dest .x - this .x);
-			this .y = this .y + t * (dest .y - this .y);
+			const
+				x = this .x,
+				y = this .y;
+
+			this .x = x + t * (destination .x - x);
+			this .y = y + t * (destination .y - y);
 			return this;
 		},
 		min: function (vector)
 		{
-			for (var i = 0, length = arguments .length; i < length; ++ i)
-			{
-				var vector = arguments [i];
+			let
+				x = this .x,
+				y = this .y;
 
-				this .x = Math .min (this .x, vector .x);
-				this .y = Math .min (this .y, vector .y);
+			for (const vector of arguments)
+			{
+				x = Math .min (x, vector .x);
+				y = Math .min (y, vector .y);
 			}
 
+			this .x = x;
+			this .y = y;
 			return this;
 		},
 		max: function (vector)
 		{
-			for (var i = 0, length = arguments .length; i < length; ++ i)
-			{
-				var vector = arguments [i];
+			let
+				x = this .x,
+				y = this .y;
 
-				this .x = Math .max (this .x, vector .x);
-				this .y = Math .max (this .y, vector .y);
+			for (const vector of arguments)
+			{
+				x = Math .max (x, vector .x);
+				y = Math .max (y, vector .y);
 			}
 
+			this .x = x;
+			this .y = y;
 			return this;
 		},
 		toString: function ()
@@ -223,122 +232,57 @@ function ($, Algorithm)
 		configurable: false
 	});
 
-	$.extend (Vector2,
+	Object .assign (Vector2,
 	{
 		Zero: new Vector2 (0, 0),
 		One: new Vector2 (1, 1),
 		negate: function (vector)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = -vector .x;
-			copy .y = -vector .y;
-			return copy;
+			return vector .copy () .negate ();
 		},
 		add: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = lhs .x + rhs .x;
-			copy .y = lhs .y + rhs .y;
-			return copy;
+			return lhs .copy () .add (rhs);
 		},
 		subtract: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = lhs .x - rhs .x;
-			copy .y = lhs .y - rhs .y;
-			return copy;
+			return lhs .copy () .subtract (rhs);
 		},
 		multiply: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = lhs .x * rhs;
-			copy .y = lhs .y * rhs;
-			return copy;
+			return lhs .copy () .multiply (rhs);
 		},
 		multVec: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = lhs .x * rhs .x;
-			copy .y = lhs .y * rhs .y;
-			return copy;
+			return lhs .copy () .multVec (rhs);
 		},
 		divide: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = lhs .x / rhs;
-			copy .y = lhs .y / rhs;
-			return copy;
+			return lhs .copy () .divide (rhs);
 		},
 		divVec: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = lhs .x / rhs .x;
-			copy .y = lhs .y / rhs .y;
-			return copy;
+			return lhs .copy () .divVec (rhs);
 		},
 		normalize: function (vector)
 		{
-			var
-				copy   = Object .create (this .prototype),
-				x      = vector .x,
-				y      = vector .y,
-				length = Math .sqrt (x * x + y * y);
-
-			if (length)
-			{
-				length = 1 / length;
-
-				copy .x = x * length;
-				copy .y = y * length;
-			}
-			else
-			{
-				copy .x = 0;
-				copy .y = 0;
-			}
-
-			return copy;
+			return vector .copy () .normalize ();
 		},
 		dot: function (lhs, rhs)
 		{
-			return lhs .dot (rhs);
+			return lhs .copy () .dot (rhs);
 		},
-		lerp: function (source, dest, t)
+		lerp: function (source, destination, t)
 		{
-			return new Vector2 (Algorithm .lerp (source .x, dest .x, t),
-			                    Algorithm .lerp (source .y, dest .y, t));
+			return source .copy () .lerp (destination, t);
 		},
 		min: function (lhs, rhs)
 		{
-			var
-				x = lhs .x,
-				y = lhs .y;
-
-			for (var i = 1, length = arguments .length; i < length; ++ i)
-			{
-				var vector = arguments [i];
-
-				x = Math .min (x, vector .x);
-				y = Math .min (y, vector .y);
-			}
-
-			return new Vector2 (x, y);
+			return Vector2 .prototype .min .apply (lhs .copy (), arguments);
 		},
 		max: function (lhs, rhs)
 		{
-			var
-				x = lhs .x,
-				y = lhs .y;
-
-			for (var i = 1, length = arguments .length; i < length; ++ i)
-			{
-				var vector = arguments [i];
-
-				x = Math .max (x, vector .x);
-				y = Math .max (y, vector .y);
-			}
-
-			return new Vector2 (x, y);
+			return Vector2 .prototype .max .apply (lhs .copy (), arguments);
 		},
 	});
 

package/src/standard/Math/Numbers/Vector3.js

@@ -48,15 +48,14 @@
 
 
 define ([
-	"jquery",
 	"standard/Math/Algorithm",
 ],
-function ($, Algorithm)
+function (Algorithm)
 {
 "use strict";
 
 	function Vector3 (x, y, z)
-	{		
+	{
 		this .x = x;
 		this .y = y;
 		this .z = z;
@@ -68,7 +67,7 @@ function ($, Algorithm)
 		length: 3,
 		copy: function ()
 		{
-			var copy = Object .create (Vector3 .prototype);
+			const copy = Object .create (Vector3 .prototype);
 			copy .x = this .x;
 			copy .y = this .y;
 			copy .z = this .z;
@@ -145,7 +144,7 @@ function ($, Algorithm)
 		},
 		cross: function (vector)
 		{
-			var x = this .x, y = this .y, z = this .z;
+			const x = this .x, y = this .y, z = this .z;
 
 			this .x = y * vector .z - z * vector .y;
 			this .y = z * vector .x - x * vector .z;
@@ -155,10 +154,8 @@ function ($, Algorithm)
 		},
 		normalize: function ()
 		{
-			var length = Math .sqrt (this .x * this .x +
-			                         this .y * this .y +
-			                         this .z * this .z);
-			
+			let length = Math .hypot (this .x, this .y, this .z);
+
 			if (length)
 			{
 				length = 1 / length;
@@ -178,62 +175,82 @@ function ($, Algorithm)
 		},
 		norm: function ()
 		{
-			return this .x * this .x +
-			       this .y * this .y +
-			       this .z * this .z;
+			let
+				x = this .x,
+				y = this .y,
+				z = this .z;
+
+			return x * x +
+			       y * y +
+			       z * z;
 		},
 		abs: function ()
 		{
-			return Math .sqrt (this .x * this .x +
-			                   this .y * this .y +
-			                   this .z * this .z);
+			return Math .hypot (this .x, this .y, this .z);
 		},
 		distance: function (vector)
 		{
-			var
-				x = this .x - vector .x,
-				y = this .y - vector .y,
-				z = this .z - vector .z;
-
-			return Math .sqrt (x * x +
-			                   y * y +
-			                   z * z);
+			return Math .hypot (this .x - vector .x,
+			                    this .y - vector .y,
+			                    this .z - vector .z);
 		},
-		lerp: function (dest, t)
+		lerp: function (destination, t)
 		{
-			this .x = this .x + t * (dest .x - this .x);
-			this .y = this .y + t * (dest .y - this .y);
-			this .z = this .z + t * (dest .z - this .z);
+			const
+				x = this .x,
+				y = this .y,
+				z = this .z;
+
+			this .x = x + t * (destination .x - x);
+			this .y = y + t * (destination .y - y);
+			this .z = z + t * (destination .z - z);
 			return this;
 		},
-		slerp: function (destination, t)
+		slerp: (function ()
 		{
-			return Algorithm .simpleSlerp (this, tmp .assign (destination), t);
-		},
+			const tmp = new Vector3 (0, 0, 0);
+
+			return function (destination, t)
+			{
+				return Algorithm .simpleSlerp (this, tmp .assign (destination), t);
+			};
+		})(),
 		min: function (vector)
 		{
-			for (var i = 0, length = arguments .length; i < length; ++ i)
-			{
-				var vector = arguments [i];
+			let
+				x = this .x,
+				y = this .y,
+				z = this .z;
 
-				this .x = Math .min (this .x, vector .x);
-				this .y = Math .min (this .y, vector .y);
-				this .z = Math .min (this .z, vector .z);
+			for (const vector of arguments)
+			{
+				x = Math .min (x, vector .x);
+				y = Math .min (y, vector .y);
+				z = Math .min (z, vector .z);
 			}
 
+			this .x = x;
+			this .y = y;
+			this .z = z;
 			return this;
 		},
 		max: function (vector)
 		{
-			for (var i = 0, length = arguments .length; i < length; ++ i)
-			{
-				var vector = arguments [i];
+			let
+				x = this .x,
+				y = this .y,
+				z = this .z;
 
-				this .x = Math .max (this .x, vector .x);
-				this .y = Math .max (this .y, vector .y);
-				this .z = Math .max (this .z, vector .z);
+			for (const vector of arguments)
+			{
+				x = Math .max (x, vector .x);
+				y = Math .max (y, vector .y);
+				z = Math .max (z, vector .z);
 			}
 
+			this .x = x;
+			this .y = y;
+			this .z = z;
 			return this;
 		},
 		toString: function ()
@@ -268,7 +285,7 @@ function ($, Algorithm)
 		configurable: false
 	});
 
-	$.extend (Vector3,
+	Object .assign (Vector3,
 	{
 		Zero: new Vector3 (0, 0, 0),
 		One: new Vector3 (1, 1, 1),
@@ -277,147 +294,61 @@ function ($, Algorithm)
 		zAxis: new Vector3 (0, 0, 1),
 		negate: function (vector)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = -vector .x;
-			copy .y = -vector .y;
-			copy .z = -vector .z;
-			return copy;
+			return vector .copy () .negate ();
 		},
 		add: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = lhs .x + rhs .x;
-			copy .y = lhs .y + rhs .y;
-			copy .z = lhs .z + rhs .z;
-			return copy;
+			return lhs .copy () .add (rhs);
 		},
 		subtract: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = lhs .x - rhs .x;
-			copy .y = lhs .y - rhs .y;
-			copy .z = lhs .z - rhs .z;
-			return copy;
+			return lhs .copy () .subtract (rhs);
 		},
 		multiply: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = lhs .x * rhs;
-			copy .y = lhs .y * rhs;
-			copy .z = lhs .z * rhs;
-			return copy;
+			return lhs .copy () .multiply (rhs);
 		},
 		multVec: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = lhs .x * rhs .x;
-			copy .y = lhs .y * rhs .y;
-			copy .z = lhs .z * rhs .z;
-			return copy;
+			return lhs .copy () .multVec (rhs);
 		},
 		divide: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = lhs .x / rhs;
-			copy .y = lhs .y / rhs;
-			copy .z = lhs .z / rhs;
-			return copy;
+			return lhs .copy () .divide (rhs);
 		},
 		divVec: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = lhs .x / rhs .x;
-			copy .y = lhs .y / rhs .y;
-			copy .z = lhs .z / rhs .z;
-			return copy;
+			return lhs .copy () .divVec (rhs);
 		},
 		cross: function (lhs, rhs)
 		{
-			var copy = Object .create (this .prototype);
-			copy .x = lhs .y * rhs .z - lhs .z * rhs .y;
-			copy .y = lhs .z * rhs .x - lhs .x * rhs .z;
-			copy .z = lhs .x * rhs .y - lhs .y * rhs .x;
-			return copy;
+			return lhs .copy () .cross (rhs);
 		},
 		normalize: function (vector)
 		{
-			var
-				copy   = Object .create (this .prototype),
-				x      = vector .x,
-				y      = vector .y,
-				z      = vector .z,
-				length = Math .sqrt (x * x + y * y + z * z);
-
-			if (length)
-			{
-				length = 1 / length;
-
-				copy .x = x * length;
-				copy .y = y * length;
-				copy .z = z * length;
-			}
-			else
-			{
-				copy .x = 0;
-				copy .y = 0;
-				copy .z = 0;
-			}
-
-			return copy;
+			return vector .copy () .normalize ();
 		},
 		dot: function (lhs, rhs)
 		{
-			return lhs .dot (rhs);
+			return lhs .copy () .dot (rhs);
 		},
-		lerp: function (source, dest, t)
+		lerp: function (source, destination, t)
 		{
-			return new Vector3 (Algorithm .lerp (source .x, dest .x, t),
-			                    Algorithm .lerp (source .y, dest .y, t),
-			                    Algorithm .lerp (source .z, dest .z, t));
+			return source .copy () .lerp (destination, t);
 		},
 		slerp: function (source, destination, t)
 		{
-			return Algorithm .simpleSlerp (source .copy (), tmp .assign (destination), t);
+			return source .copy () .slerp (destination, t);
 		},
 		min: function (lhs, rhs)
 		{
-			var
-				x = lhs .x,
-				y = lhs .y,
-				z = lhs .z;
-
-			for (var i = 1, length = arguments .length; i < length; ++ i)
-			{
-				var vector = arguments [i];
-
-				x = Math .min (x, vector .x);
-				y = Math .min (y, vector .y);
-				z = Math .min (z, vector .z);
-			}
-
-			return new Vector3 (x, y, z);
+			return Vector3 .prototype .min .apply (lhs .copy (), arguments);
 		},
 		max: function (lhs, rhs)
 		{
-			var
-				x = lhs .x,
-				y = lhs .y,
-				z = lhs .z;
-
-			for (var i = 1, length = arguments .length; i < length; ++ i)
-			{
-				var vector = arguments [i];
-
-				x = Math .max (x, vector .x);
-				y = Math .max (y, vector .y);
-				z = Math .max (z, vector .z);
-			}
-
-			return new Vector3 (x, y, z);
+			return Vector3 .prototype .max .apply (lhs .copy (), arguments);
 		},
 	});
 
-	var tmp = new Vector3 (0, 0, 0);
-
 	return Vector3;
 });