x_ite 8.7.8 → 8.8.0

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

@@ -57,17 +57,16 @@ function Quaternion (x, y, z, w)
    this .w = w;
 }
 
-Quaternion .prototype =
+Object .assign (Quaternion .prototype,
 {
-   constructor: Quaternion,
-   [Symbol .iterator]: function* ()
+   *[Symbol .iterator] ()
    {
       yield this .x;
       yield this .y;
       yield this .z;
       yield this .w;
    },
-   copy: function ()
+   copy ()
    {
       const copy = Object .create (Quaternion .prototype);
       copy .x = this .x;
@@ -76,7 +75,7 @@ Quaternion .prototype =
       copy .w = this .w;
       return copy;
    },
-   assign: function (quat)
+   assign (quat)
    {
       this .x = quat .x;
       this .y = quat .y;
@@ -84,7 +83,7 @@ Quaternion .prototype =
       this .w = quat .w;
       return this;
    },
-   set: function (x, y, z, w)
+   set (x, y, z, w)
    {
       this .x = x;
       this .y = y;
@@ -92,7 +91,7 @@ Quaternion .prototype =
       this .w = w;
       return this;
    },
-   setMatrix: function (matrix)
+   setMatrix (matrix)
    {
       // First, find largest diagonal in matrix:
       if (matrix [0] > matrix [4])
@@ -135,7 +134,7 @@ Quaternion .prototype =
 
       return this;
    },
-   getMatrix: function (matrix = new Matrix3 ())
+   getMatrix (matrix = new Matrix3 ())
    {
       const { x, y, z, w } = this;
 
@@ -164,22 +163,22 @@ Quaternion .prototype =
 
       return matrix;
    },
-   isReal: function ()
+   isReal ()
    {
       return !(this .x || this .y || this .z);
    },
-   isImag: function ()
+   isImag ()
    {
       return !this .w;
    },
-   equals: function (quat)
+   equals (quat)
    {
       return this .x === quat .x &&
              this .y === quat .y &&
              this .z === quat .z &&
              this .w === quat .w;
    },
-   negate: function ()
+   negate ()
    {
       this .x = -this .x;
       this .y = -this .y;
@@ -187,14 +186,14 @@ Quaternion .prototype =
       this .w = -this .w;
       return this;
    },
-   inverse: function ()
+   inverse ()
    {
       this .x = -this .x;
       this .y = -this .y;
       this .z = -this .z;
       return this;
    },
-   add: function (quat)
+   add (quat)
    {
       this .x += quat .x;
       this .y += quat .y;
@@ -202,7 +201,7 @@ Quaternion .prototype =
       this .w += quat .w;
       return this;
    },
-   subtract: function (quat)
+   subtract (quat)
    {
       this .x -= quat .x;
       this .y -= quat .y;
@@ -210,7 +209,7 @@ Quaternion .prototype =
       this .w -= quat .w;
       return this;
    },
-   multiply: function (value)
+   multiply (value)
    {
       this .x *= value;
       this .y *= value;
@@ -218,7 +217,7 @@ Quaternion .prototype =
       this .w *= value;
       return this;
    },
-   multLeft: function (quat)
+   multLeft (quat)
    {
       const
          { x: ax, y: ay, z: az, w: aw } = this,
@@ -231,7 +230,7 @@ Quaternion .prototype =
 
       return this;
    },
-   multRight: function (quat)
+   multRight (quat)
    {
       const
          { x: ax, y: ay, z: az, w: aw } = this,
@@ -244,7 +243,7 @@ Quaternion .prototype =
 
       return this;
    },
-   divide: function (value)
+   divide (value)
    {
       this .x /= value;
       this .y /= value;
@@ -252,7 +251,7 @@ Quaternion .prototype =
       this .w /= value;
       return this;
    },
-   multVecQuat: function (vector)
+   multVecQuat (vector)
    {
       const
          { x: qx, y: qy, z: qz, w: qw } = this,
@@ -267,7 +266,7 @@ Quaternion .prototype =
 
       return vector;
    },
-   multQuatVec: function (vector)
+   multQuatVec (vector)
    {
       const
          { x: qx, y: qy, z: qz, w: qw } = this,
@@ -282,7 +281,7 @@ Quaternion .prototype =
 
       return vector;
    },
-   normalize: function ()
+   normalize ()
    {
       const length = Math .hypot (this .x, this .y, this .z, this .w);
 
@@ -296,14 +295,14 @@ Quaternion .prototype =
 
       return this;
    },
-   dot: function (quat)
+   dot (quat)
    {
       return this .x * quat .x +
              this .y * quat .y +
              this .z * quat .z +
              this .w * quat .w;
    },
-   norm: function ()
+   norm ()
    {
       const { x, y, z, w } = this;
 
@@ -312,11 +311,11 @@ Quaternion .prototype =
              z * z +
              w * w;
    },
-   magnitude: function ()
+   magnitude ()
    {
       return Math .hypot (this .x, this .y, this .z, this .w);
    },
-   pow: function (exponent)
+   pow (exponent)
    {
       if (exponent instanceof Quaternion)
          return this .assign (e .assign (exponent) .multRight (this .log ()) .exp ());
@@ -338,7 +337,7 @@ Quaternion .prototype =
       this .w  = ltoe * Math .cos (et);
       return this;
    },
-   log: function ()
+   log ()
    {
       if (this .isReal ())
       {
@@ -360,7 +359,7 @@ Quaternion .prototype =
       this .w = w;
       return this;
    },
-   exp: function ()
+   exp ()
    {
       if (this .isReal ())
          return this .set (0, 0, 0, Math .exp (this .w));
@@ -378,11 +377,11 @@ Quaternion .prototype =
       this .w = w;
       return this;
    },
-   slerp: function (destination, t)
+   slerp (destination, t)
    {
       return Algorithm .slerp (this, t1 .assign (destination), t);
    },
-   squad: function (a, b, destination, t)
+   squad (a, b, destination, t)
    {
       // We must use shortest path slerp to prevent flipping.  Also see spline.
 
@@ -390,41 +389,41 @@ Quaternion .prototype =
                                Algorithm .slerp (t2 .assign (a), t3 .assign (b), t),
                                2 * t * (1 - t));
    },
-   toString: function ()
+   toString ()
    {
       return this .x + " " +
              this .y + " " +
              this .z + " " +
              this .w;
    },
-};
+});
 
 Object .defineProperties (Quaternion .prototype,
 {
    length: { value: 4 },
    0:
    {
-      get: function () { return this .x; },
-      set: function (value) { this .x = value; },
+      get () { return this .x; },
+      set (value) { this .x = value; },
    },
    1:
    {
-      get: function () { return this .y; },
-      set: function (value) { this .y = value; },
+      get () { return this .y; },
+      set (value) { this .y = value; },
    },
    2:
    {
-      get: function () { return this .z; },
-      set: function (value) { this .z = value; },
+      get () { return this .z; },
+      set (value) { this .z = value; },
    },
    3:
    {
-      get: function () { return this .w; },
-      set: function (value) { this .w = value; },
+      get () { return this .w; },
+      set (value) { this .w = value; },
    },
    real:
    {
-      get: function () { return this .w; },
+      get () { return this .w; },
    },
    imag:
    {

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

@@ -105,17 +105,16 @@ function Rotation4 (x, y, z, angle)
    }
 }
 
-Rotation4 .prototype =
+Object .assign (Rotation4 .prototype,
 {
-   constructor: Rotation4,
-   [Symbol .iterator]: function* ()
+   *[Symbol .iterator] ()
    {
       yield this [_x];
       yield this [_y];
       yield this [_z];
       yield this [_angle];
    },
-   update: function ()
+   update ()
    {
       const rotation = this .get ();
 
@@ -126,7 +125,7 @@ Rotation4 .prototype =
 
       return this;
    },
-   copy: function ()
+   copy ()
    {
       const copy = Object .create (Rotation4 .prototype);
 
@@ -139,7 +138,7 @@ Rotation4 .prototype =
 
       return copy;
    },
-   assign: function (rotation)
+   assign (rotation)
    {
       this [_x]     = rotation [_x];
       this [_y]     = rotation [_y];
@@ -150,7 +149,7 @@ Rotation4 .prototype =
 
       return this;
    },
-   set: function (x, y, z, angle)
+   set (x, y, z, angle)
    {
       this [_x]     = x;
       this [_y]     = y;
@@ -211,7 +210,7 @@ Rotation4 .prototype =
          }
       };
    })(),
-   setAxisAngle: function (axis, angle)
+   setAxisAngle (axis, angle)
    {
       return this .set (axis .x, axis .y, axis .z, angle);
    },
@@ -276,103 +275,103 @@ Rotation4 .prototype =
          return this;
       };
    })(),
-   setAxis: function (vector)
+   setAxis (vector)
    {
       this .set (vector .x, vector .y, vector .z, this [_angle]);
    },
-   getAxis: function (axis = new Vector3 (0, 0, 0))
+   getAxis (axis = new Vector3 (0, 0, 0))
    {
       return axis .set (this [_x], this [_y], this [_z]);
    },
-   setQuaternion: function (quaternion)
+   setQuaternion (quaternion)
    {
       this [_quaternion] .assign (quaternion) .normalize ();
       this .update ();
       return this;
    },
-   getQuaternion: function (quaternion = new Quaternion (0, 0, 0, 1))
+   getQuaternion (quaternion = new Quaternion (0, 0, 0, 1))
    {
       return quaternion .assign (this [_quaternion]);
    },
-   setMatrix: function (matrix)
+   setMatrix (matrix)
    {
       this [_quaternion] .setMatrix (matrix) .normalize ();
       this .update ();
       return this;
    },
-   getMatrix: function (matrix = new Matrix3 ())
+   getMatrix (matrix = new Matrix3 ())
    {
       return this [_quaternion] .getMatrix (matrix);
    },
-   equals: function (rotation)
+   equals (rotation)
    {
       return this [_quaternion] .equals (rotation [_quaternion]);
    },
-   inverse: function ()
+   inverse ()
    {
       this [_quaternion] .inverse ();
       this .update ();
       return this;
    },
-   multLeft: function (rotation)
+   multLeft (rotation)
    {
       this [_quaternion] .multLeft (rotation [_quaternion]) .normalize ();
       this .update ();
       return this;
    },
-   multRight: function (rotation)
+   multRight (rotation)
    {
       this [_quaternion] .multRight (rotation [_quaternion]) .normalize ();
       this .update ();
       return this;
    },
-   multVecRot: function (vector)
+   multVecRot (vector)
    {
       return this [_quaternion] .multVecQuat (vector);
    },
-   multRotVec: function (vector)
+   multRotVec (vector)
    {
       return this [_quaternion] .multQuatVec (vector);
    },
-   normalize: function ()
+   normalize ()
    {
       this [_quaternion] .normalize ();
       this .update ();
       return this;
    },
-   pow: function (exponent)
+   pow (exponent)
    {
       this [_quaternion] .pow (exponent);
       this .update ();
       return this;
    },
-   slerp: function (dest, t)
+   slerp (dest, t)
    {
       this [_quaternion] .slerp (dest [_quaternion], t);
       this .update ();
       return this;
    },
-   squad: function (a, b, dest, t)
+   squad (a, b, dest, t)
    {
       this [_quaternion] .squad (a [_quaternion], b [_quaternion], dest [_quaternion], t);
       this .update ();
       return this;
    },
-   toString: function ()
+   toString ()
    {
       return this [_x] + " " +
              this [_y] + " " +
              this [_z] + " " +
              this [_angle];
    }
-};
+});
 
 const x = {
-   get: function ()
+   get ()
    {
       return this [_x];
    },
-   set: function (x)
+   set (x)
    {
       this [_x] = x;
       this .set (x, this [_y], this [_z], this [_angle]);
@@ -381,11 +380,11 @@ const x = {
 };
 
 const y = {
-   get: function ()
+   get ()
    {
       return this [_y];
    },
-   set: function (y)
+   set (y)
    {
       this [_y] = y;
       this .set (this [_x], y, this [_z], this [_angle]);
@@ -394,11 +393,11 @@ const y = {
 };
 
 const z = {
-   get: function ()
+   get ()
    {
       return this [_z];
    },
-   set: function (z)
+   set (z)
    {
       this [_z] = z;
       this .set (this [_x], this [_y], z, this [_angle]);
@@ -407,11 +406,11 @@ const z = {
 };
 
 const angle = {
-   get: function ()
+   get ()
    {
       return this [_angle];
    },
-   set: function (angle)
+   set (angle)
    {
       this [_angle] = angle;
       this .set (this [_x], this [_y], this [_z], angle);
@@ -444,7 +443,7 @@ Object .defineProperties (Rotation4 .prototype,
 Object .assign (Rotation4,
 {
    Identity: new Rotation4 (),
-   spline: function (r0, r1, r2)
+   spline (r0, r1, r2)
    {
       const copy = Object .create (this .prototype);
       copy [_quaternion] = Quaternion .spline (r0 [_quaternion], r1 [_quaternion], r2 [_quaternion]);

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

@@ -51,87 +51,86 @@ function Vector2 (x, y)
    this .y = y;
 }
 
-Vector2 .prototype =
+Object .assign (Vector2 .prototype,
 {
-   constructor: Vector2,
-   [Symbol .iterator]: function* ()
+   *[Symbol .iterator] ()
    {
       yield this .x;
       yield this .y;
    },
-   copy: function ()
+   copy ()
    {
       const copy = Object .create (Vector2 .prototype);
       copy .x = this .x;
       copy .y = this .y;
       return copy;
    },
-   assign: function (vector)
+   assign (vector)
    {
       this .x = vector .x;
       this .y = vector .y;
       return this;
    },
-   set: function (x, y)
+   set (x, y)
    {
       this .x = x;
       this .y = y;
       return this;
    },
-   equals: function (vector)
+   equals (vector)
    {
       return this .x === vector .x &&
              this .y === vector .y;
    },
-   negate: function ()
+   negate ()
    {
       this .x = -this .x;
       this .y = -this .y;
       return this;
    },
-   inverse: function ()
+   inverse ()
    {
       this .x = 1 / this .x;
       this .y = 1 / this .y;
       return this;
    },
-   add: function (vector)
+   add (vector)
    {
       this .x += vector .x;
       this .y += vector .y;
       return this;
    },
-   subtract: function (vector)
+   subtract (vector)
    {
       this .x -= vector .x;
       this .y -= vector .y;
       return this;
    },
-   multiply: function (value)
+   multiply (value)
    {
       this .x *= value;
       this .y *= value;
       return this;
    },
-   multVec: function (vector)
+   multVec (vector)
    {
       this .x *= vector .x;
       this .y *= vector .y;
       return this;
    },
-   divide: function (value)
+   divide (value)
    {
       this .x /= value;
       this .y /= value;
       return this;
    },
-   divVec: function (vector)
+   divVec (vector)
    {
       this .x /= vector .x;
       this .y /= vector .y;
       return this;
    },
-   normalize: function ()
+   normalize ()
    {
       const length = Math .hypot (this .x, this .y);
 
@@ -143,28 +142,28 @@ Vector2 .prototype =
 
       return this;
    },
-   dot: function (vector)
+   dot (vector)
    {
       return this .x * vector .x +
              this .y * vector .y;
    },
-   norm: function ()
+   norm ()
    {
       const { x, y } = this;
 
       return x * x +
              y * y;
    },
-   magnitude: function ()
+   magnitude ()
    {
       return Math .hypot (this .x, this .y);
    },
-   distance: function (vector)
+   distance (vector)
    {
       return Math .hypot (this .x - vector .x,
                           this .y - vector .y);
    },
-   lerp: function (destination, t)
+   lerp (destination, t)
    {
       const { x, y } = this;
 
@@ -172,13 +171,13 @@ Vector2 .prototype =
       this .y = y + t * (destination .y - y);
       return this;
    },
-   abs: function ()
+   abs ()
    {
       this .x = Math .abs (this .x);
       this .y = Math .abs (this .y);
       return this;
    },
-   min: function (vector)
+   min (vector)
    {
       let { x, y } = this;
 
@@ -192,7 +191,7 @@ Vector2 .prototype =
       this .y = y;
       return this;
    },
-   max: function (vector)
+   max (vector)
    {
       let { x, y } = this;
 
@@ -206,25 +205,25 @@ Vector2 .prototype =
       this .y = y;
       return this;
    },
-   toString: function ()
+   toString ()
    {
       return this .x + " " +
              this .y;
    }
-};
+});
 
 Object .defineProperties (Vector2 .prototype,
 {
    length: { value: 2 },
    0:
    {
-      get: function () { return this .x; },
-      set: function (value) { this .x = value; },
+      get () { return this .x; },
+      set (value) { this .x = value; },
    },
    1:
    {
-      get: function () { return this .y; },
-      set: function (value) { this .y = value; },
+      get () { return this .y; },
+      set (value) { this .y = value; },
    },
 });