define(["require", "exports"], function (require, exports) {
var compute = function (f, a, b, coord, pack) {
var a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7, x0, x1, x2, x3, x4, x5, x6, x7;
a0 = coord(a, 0);
a1 = coord(a, 1);
a2 = coord(a, 2);
a3 = coord(a, 3);
a4 = coord(a, 4);
a5 = coord(a, 5);
a6 = coord(a, 6);
a7 = coord(a, 7);
b0 = coord(b, 0);
b1 = coord(b, 1);
b2 = coord(b, 2);
b3 = coord(b, 3);
b4 = coord(b, 4);
b5 = coord(b, 5);
b6 = coord(b, 6);
b7 = coord(b, 7);
x0 = f(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7, 0);
x1 = f(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7, 1);
x2 = f(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7, 2);
x3 = f(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7, 3);
x4 = f(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7, 4);
x5 = f(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7, 5);
x6 = f(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7, 6);
x7 = f(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7, 7);
return pack(x0, x1, x2, x3, x4, x5, x6, x7);
};
function addE3(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7, index) {
a0 = +a0;
a1 = +a1;
a2 = +a2;
a3 = +a3;
a4 = +a4;
a5 = +a5;
a6 = +a6;
a7 = +a7;
b0 = +b0;
b1 = +b1;
b2 = +b2;
b3 = +b3;
b4 = +b4;
b5 = +b5;
b6 = +b6;
b7 = +b7;
index = index | 0;
var x = 0.0;
switch (~(~index)) {
case 0:
{
x = +(a0 + b0);
}
break;
case 1:
{
x = +(a1 + b1);
}
break;
case 2:
{
x = +(a2 + b2);
}
break;
case 3:
{
x = +(a3 + b3);
}
break;
case 4:
{
x = +(a4 + b4);
}
break;
case 5:
{
x = +(a5 + b5);
}
break;
case 6:
{
x = +(a6 + b6);
}
break;
case 7:
{
x = +(a7 + b7);
}
break;
default: {
throw new Error("index must be in the range [0..7]");
}
}
return +x;
}
function subE3(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7, index) {
a0 = +a0;
a1 = +a1;
a2 = +a2;
a3 = +a3;
a4 = +a4;
a5 = +a5;
a6 = +a6;
a7 = +a7;
b0 = +b0;
b1 = +b1;
b2 = +b2;
b3 = +b3;
b4 = +b4;
b5 = +b5;
b6 = +b6;
b7 = +b7;
index = index | 0;
var x = 0.0;
switch (~(~index)) {
case 0:
{
x = +(a0 - b0);
}
break;
case 1:
{
x = +(a1 - b1);
}
break;
case 2:
{
x = +(a2 - b2);
}
break;
case 3:
{
x = +(a3 - b3);
}
break;
case 4:
{
x = +(a4 - b4);
}
break;
case 5:
{
x = +(a5 - b5);
}
break;
case 6:
{
x = +(a6 - b6);
}
break;
case 7:
{
x = +(a7 - b7);
}
break;
default: {
throw new Error("index must be in the range [0..7]");
}
}
return +x;
}
/**
*
*/
function mulE3(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7, index) {
a0 = +a0;
a1 = +a1;
a2 = +a2;
a3 = +a3;
a4 = +a4;
a5 = +a5;
a6 = +a6;
a7 = +a7;
b0 = +b0;
b1 = +b1;
b2 = +b2;
b3 = +b3;
b4 = +b4;
b5 = +b5;
b6 = +b6;
b7 = +b7;
index = index | 0;
var x = 0.0;
switch (~(~index)) {
case 0:
{
x = +(a0 * b0 + a1 * b1 + a2 * b2 + a3 * b3 - a4 * b4 - a5 * b5 - a6 * b6 - a7 * b7);
}
break;
case 1:
{
x = +(a0 * b1 + a1 * b0 - a2 * b4 + a3 * b6 + a4 * b2 - a5 * b7 - a6 * b3 - a7 * b5);
}
break;
case 2:
{
x = +(a0 * b2 + a1 * b4 + a2 * b0 - a3 * b5 - a4 * b1 + a5 * b3 - a6 * b7 - a7 * b6);
}
break;
case 3:
{
x = +(a0 * b3 - a1 * b6 + a2 * b5 + a3 * b0 - a4 * b7 - a5 * b2 + a6 * b1 - a7 * b4);
}
break;
case 4:
{
x = +(a0 * b4 + a1 * b2 - a2 * b1 + a3 * b7 + a4 * b0 - a5 * b6 + a6 * b5 + a7 * b3);
}
break;
case 5:
{
x = +(a0 * b5 + a1 * b7 + a2 * b3 - a3 * b2 + a4 * b6 + a5 * b0 - a6 * b4 + a7 * b1);
}
break;
case 6:
{
x = +(a0 * b6 - a1 * b3 + a2 * b7 + a3 * b1 - a4 * b5 + a5 * b4 + a6 * b0 + a7 * b2);
}
break;
case 7:
{
x = +(a0 * b7 + a1 * b5 + a2 * b6 + a3 * b4 + a4 * b3 + a5 * b1 + a6 * b2 + a7 * b0);
}
break;
default: {
throw new Error("index must be in the range [0..7]");
}
}
return +x;
}
function extE3(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7, index) {
a0 = +a0;
a1 = +a1;
a2 = +a2;
a3 = +a3;
a4 = +a4;
a5 = +a5;
a6 = +a6;
a7 = +a7;
b0 = +b0;
b1 = +b1;
b2 = +b2;
b3 = +b3;
b4 = +b4;
b5 = +b5;
b6 = +b6;
b7 = +b7;
index = index | 0;
var x = 0.0;
switch (~(~index)) {
case 0:
{
x = +(a0 * b0);
}
break;
case 1:
{
x = +(a0 * b1 + a1 * b0);
}
break;
case 2:
{
x = +(a0 * b2 + a2 * b0);
}
break;
case 3:
{
x = +(a0 * b3 + a3 * b0);
}
break;
case 4:
{
x = +(a0 * b4 + a1 * b2 - a2 * b1 + a4 * b0);
}
break;
case 5:
{
x = +(a0 * b5 + a2 * b3 - a3 * b2 + a5 * b0);
}
break;
case 6:
{
x = +(a0 * b6 - a1 * b3 + a3 * b1 + a6 * b0);
}
break;
case 7:
{
x = +(a0 * b7 + a1 * b5 + a2 * b6 + a3 * b4 + a4 * b3 + a5 * b1 + a6 * b2 + a7 * b0);
}
break;
default: {
throw new Error("index must be in the range [0..7]");
}
}
return +x;
}
function lcoE3(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7, index) {
a0 = +a0;
a1 = +a1;
a2 = +a2;
a3 = +a3;
a4 = +a4;
a5 = +a5;
a6 = +a6;
a7 = +a7;
b0 = +b0;
b1 = +b1;
b2 = +b2;
b3 = +b3;
b4 = +b4;
b5 = +b5;
b6 = +b6;
b7 = +b7;
index = index | 0;
var x = 0.0;
switch (~(~index)) {
case 0:
{
x = +(a0 * b0 + a1 * b1 + a2 * b2 + a3 * b3 - a4 * b4 - a5 * b5 - a6 * b6 - a7 * b7);
}
break;
case 1:
{
x = +(a0 * b1 - a2 * b4 + a3 * b6 - a5 * b7);
}
break;
case 2:
{
x = +(a0 * b2 + a1 * b4 - a3 * b5 - a6 * b7);
}
break;
case 3:
{
x = +(a0 * b3 - a1 * b6 + a2 * b5 - a4 * b7);
}
break;
case 4:
{
x = +(a0 * b4 + a3 * b7);
}
break;
case 5:
{
x = +(a0 * b5 + a1 * b7);
}
break;
case 6:
{
x = +(a0 * b6 + a2 * b7);
}
break;
case 7:
{
x = +(a0 * b7);
}
break;
default: {
throw new Error("index must be in the range [0..7]");
}
}
return +x;
}
function rcoE3(a0, a1, a2, a3, a4, a5, a6, a7, b0, b1, b2, b3, b4, b5, b6, b7, index) {
a0 = +a0;
a1 = +a1;
a2 = +a2;
a3 = +a3;
a4 = +a4;
a5 = +a5;
a6 = +a6;
a7 = +a7;
b0 = +b0;
b1 = +b1;
b2 = +b2;
b3 = +b3;
b4 = +b4;
b5 = +b5;
b6 = +b6;
b7 = +b7;
index = index | 0;
var x = 0.0;
switch (~(~index)) {
case 0:
{
x = +(a0 * b0 + a1 * b1 + a2 * b2 + a3 * b3 - a4 * b4 - a5 * b5 - a6 * b6 - a7 * b7);
}
break;
case 1:
{
x = +(+a1 * b0 + a4 * b2 - a6 * b3 - a7 * b5);
}
break;
case 2:
{
x = +(+a2 * b0 - a4 * b1 + a5 * b3 - a7 * b6);
}
break;
case 3:
{
x = +(+a3 * b0 - a5 * b2 + a6 * b1 - a7 * b4);
}
break;
case 4:
{
x = +(+a4 * b0 + a7 * b3);
}
break;
case 5:
{
x = +(+a5 * b0 + a7 * b1);
}
break;
case 6:
{
x = +(+a6 * b0 + a7 * b2);
}
break;
case 7:
{
x = +(+a7 * b0);
}
break;
default: {
throw new Error("index must be in the range [0..7]");
}
}
return +x;
}
var divide = function (a000, a001, a010, a011, a100, a101, a110, a111, b000, b001, b010, b011, b100, b101, b110, b111, dst) {
var c000, c001, c010, c011, c100, c101, c110, c111, i000, i001, i010, i011, i100, i101, i110, i111, k000, m000, m001, m010, m011, m100, m101, m110, m111, r000, r001, r010, r011, r100, r101, r110, r111, s000, s001, s010, s011, s100, s101, s110, s111, w, x, x000, x001, x010, x011, x100, x101, x110, x111, xy, xyz, y, yz, z, zx;
r000 = +b000;
r001 = +b001;
r010 = +b010;
r011 = -b011;
r100 = +b100;
r101 = -b101;
r110 = -b110;
r111 = -b111;
m000 = mulE3(b000, b001, b010, b100, b011, b110, -b101, b111, r000, r001, r010, r100, r011, r110, -r101, r111, 0);
m001 = mulE3(b000, b001, b010, b100, b011, b110, -b101, b111, r000, r001, r010, r100, r011, r110, -r101, r111, 1);
m010 = mulE3(b000, b001, b010, b100, b011, b110, -b101, b111, r000, r001, r010, r100, r011, r110, -r101, r111, 2);
m011 = 0;
m100 = mulE3(b000, b001, b010, b100, b011, b110, -b101, b111, r000, r001, r010, r100, r011, r110, -r101, r111, 3);
m101 = 0;
m110 = 0;
m111 = 0;
c000 = +m000;
c001 = -m001;
c010 = -m010;
c011 = -m011;
c100 = -m100;
c101 = -m101;
c110 = -m110;
c111 = +m111;
s000 = mulE3(r000, r001, r010, r100, r011, r110, -r101, r111, c000, c001, c010, c100, c011, c110, -c101, c111, 0);
s001 = mulE3(r000, r001, r010, r100, r011, r110, -r101, r111, c000, c001, c010, c100, c011, c110, -c101, c111, 1);
s010 = mulE3(r000, r001, r010, r100, r011, r110, -r101, r111, c000, c001, c010, c100, c011, c110, -c101, c111, 2);
s011 = mulE3(r000, r001, r010, r100, r011, r110, -r101, r111, c000, c001, c010, c100, c011, c110, -c101, c111, 4);
s100 = mulE3(r000, r001, r010, r100, r011, r110, -r101, r111, c000, c001, c010, c100, c011, c110, -c101, c111, 3);
s101 = -mulE3(r000, r001, r010, r100, r011, r110, -r101, r111, c000, c001, c010, c100, c011, c110, -c101, c111, 6);
s110 = mulE3(r000, r001, r010, r100, r011, r110, -r101, r111, c000, c001, c010, c100, c011, c110, -c101, c111, 5);
s111 = mulE3(r000, r001, r010, r100, r011, r110, -r101, r111, c000, c001, c010, c100, c011, c110, -c101, c111, 7);
k000 = mulE3(b000, b001, b010, b100, b011, b110, -b101, b111, s000, s001, s010, s100, s011, s110, -s101, s111, 0);
i000 = s000 / k000;
i001 = s001 / k000;
i010 = s010 / k000;
i011 = s011 / k000;
i100 = s100 / k000;
i101 = s101 / k000;
i110 = s110 / k000;
i111 = s111 / k000;
x000 = mulE3(a000, a001, a010, a100, a011, a110, -a101, a111, i000, i001, i010, i100, i011, i110, -i101, i111, 0);
x001 = mulE3(a000, a001, a010, a100, a011, a110, -a101, a111, i000, i001, i010, i100, i011, i110, -i101, i111, 1);
x010 = mulE3(a000, a001, a010, a100, a011, a110, -a101, a111, i000, i001, i010, i100, i011, i110, -i101, i111, 2);
x011 = mulE3(a000, a001, a010, a100, a011, a110, -a101, a111, i000, i001, i010, i100, i011, i110, -i101, i111, 4);
x100 = mulE3(a000, a001, a010, a100, a011, a110, -a101, a111, i000, i001, i010, i100, i011, i110, -i101, i111, 3);
x101 = -mulE3(a000, a001, a010, a100, a011, a110, -a101, a111, i000, i001, i010, i100, i011, i110, -i101, i111, 6);
x110 = mulE3(a000, a001, a010, a100, a011, a110, -a101, a111, i000, i001, i010, i100, i011, i110, -i101, i111, 5);
x111 = mulE3(a000, a001, a010, a100, a011, a110, -a101, a111, i000, i001, i010, i100, i011, i110, -i101, i111, 7);
w = x000;
x = x001;
y = x010;
z = x100;
xy = x011;
yz = x110;
zx = -x101;
xyz = x111;
if (typeof dst !== 'undefined') {
dst.w = w;
dst.x = x;
dst.y = y;
dst.z = z;
dst.xy = xy;
dst.yz = yz;
dst.zx = zx;
return dst.xyz = xyz;
}
else {
return new Euclidean3(w, x, y, z, xy, yz, zx, xyz);
}
};
function stringFromCoordinates(coordinates, labels) {
var i, _i, _ref;
var str;
var sb = [];
var append = function (coord, label) {
var n;
if (coord !== 0) {
if (coord >= 0) {
if (sb.length > 0) {
sb.push("+");
}
}
else {
sb.push("-");
}
n = Math.abs(coord);
if (n === 1) {
sb.push(label);
}
else {
sb.push(n.toString());
if (label !== "1") {
sb.push("*");
sb.push(label);
}
}
}
};
for (i = _i = 0, _ref = coordinates.length - 1; 0 <= _ref ? _i <= _ref : _i >= _ref; i = 0 <= _ref ? ++_i : --_i) {
append(coordinates[i], labels[i]);
}
if (sb.length > 0) {
str = sb.join("");
}
else {
str = "0";
}
return str;
}
var Euclidean3 = (function () {
/**
* The Euclidean3 class represents a multivector for a 3-dimensional linear space with a Euclidean metric.
*
* @class Euclidean3
* @constructor
* @param {number} w The scalar part of the multivector.
* @param {number} x The vector component of the multivector in the x-direction.
* @param {number} y The vector component of the multivector in the y-direction.
* @param {number} z The vector component of the multivector in the z-direction.
* @param {number} xy The bivector component of the multivector in the xy-plane.
* @param {number} yz The bivector component of the multivector in the yz-plane.
* @param {number} zx The bivector component of the multivector in the zx-plane.
* @param {number} xyz The pseudoscalar part of the multivector.
*/
function Euclidean3(w, x, y, z, xy, yz, zx, xyz) {
this.w = w || 0;
this.x = x || 0;
this.y = y || 0;
this.z = z || 0;
this.xy = xy || 0;
this.yz = yz || 0;
this.zx = zx || 0;
this.xyz = xyz || 0;
}
Euclidean3.fromCartesian = function (w, x, y, z, xy, yz, zx, xyz) {
return new Euclidean3(w, x, y, z, xy, yz, zx, xyz);
};
Euclidean3.prototype.coordinates = function () {
return [this.w, this.x, this.y, this.z, this.xy, this.yz, this.zx, this.xyz];
};
Euclidean3.prototype.coordinate = function (index) {
switch (index) {
case 0:
return this.w;
case 1:
return this.x;
case 2:
return this.y;
case 3:
return this.z;
case 4:
return this.xy;
case 5:
return this.yz;
case 6:
return this.zx;
case 7:
return this.xyz;
default:
throw new Error("index must be in the range [0..7]");
}
};
Euclidean3.prototype.add = function (rhs) {
var coord, pack;
coord = function (x, n) {
return x[n];
};
pack = function (w, x, y, z, xy, yz, zx, xyz) {
return Euclidean3.fromCartesian(w, x, y, z, xy, yz, zx, xyz);
};
return compute(addE3, [this.w, this.x, this.y, this.z, this.xy, this.yz, this.zx, this.xyz], [rhs.w, rhs.x, rhs.y, rhs.z, rhs.xy, rhs.yz, rhs.zx, rhs.xyz], coord, pack);
};
Euclidean3.prototype.sub = function (rhs) {
var coord, pack;
coord = function (x, n) {
return x[n];
};
pack = function (w, x, y, z, xy, yz, zx, xyz) {
return Euclidean3.fromCartesian(w, x, y, z, xy, yz, zx, xyz);
};
return compute(subE3, [this.w, this.x, this.y, this.z, this.xy, this.yz, this.zx, this.xyz], [rhs.w, rhs.x, rhs.y, rhs.z, rhs.xy, rhs.yz, rhs.zx, rhs.xyz], coord, pack);
};
Euclidean3.prototype.mul = function (rhs) {
var coord, pack;
if (typeof rhs === 'number') {
return this.scalarMultiply(rhs);
}
else {
coord = function (x, n) {
return x[n];
};
pack = function (w, x, y, z, xy, yz, zx, xyz) {
return Euclidean3.fromCartesian(w, x, y, z, xy, yz, zx, xyz);
};
return compute(mulE3, [this.w, this.x, this.y, this.z, this.xy, this.yz, this.zx, this.xyz], [rhs.w, rhs.x, rhs.y, rhs.z, rhs.xy, rhs.yz, rhs.zx, rhs.xyz], coord, pack);
}
};
Euclidean3.prototype.scalarMultiply = function (rhs) {
return new Euclidean3(this.w * rhs, this.x * rhs, this.y * rhs, this.z * rhs, this.xy * rhs, this.yz * rhs, this.zx * rhs, this.xyz * rhs);
};
Euclidean3.prototype.div = function (rhs) {
if (typeof rhs === 'number') {
return new Euclidean3(this.w / rhs, this.x / rhs, this.y / rhs, this.z / rhs, this.xy / rhs, this.yz / rhs, this.zx / rhs, this.xyz / rhs);
}
else {
return divide(this.w, this.x, this.y, this.xy, this.z, -this.zx, this.yz, this.xyz, rhs.w, rhs.x, rhs.y, rhs.xy, rhs.z, -rhs.zx, rhs.yz, rhs.xyz, void 0);
}
};
Euclidean3.prototype.wedge = function (rhs) {
var coord, pack;
coord = function (x, n) {
return x[n];
};
pack = function (w, x, y, z, xy, yz, zx, xyz) {
return Euclidean3.fromCartesian(w, x, y, z, xy, yz, zx, xyz);
};
return compute(extE3, [this.w, this.x, this.y, this.z, this.xy, this.yz, this.zx, this.xyz], [rhs.w, rhs.x, rhs.y, rhs.z, rhs.xy, rhs.yz, rhs.zx, rhs.xyz], coord, pack);
};
Euclidean3.prototype.lshift = function (rhs) {
var coord, pack;
coord = function (x, n) {
return x[n];
};
pack = function (w, x, y, z, xy, yz, zx, xyz) {
return Euclidean3.fromCartesian(w, x, y, z, xy, yz, zx, xyz);
};
return compute(lcoE3, [this.w, this.x, this.y, this.z, this.xy, this.yz, this.zx, this.xyz], [rhs.w, rhs.x, rhs.y, rhs.z, rhs.xy, rhs.yz, rhs.zx, rhs.xyz], coord, pack);
};
Euclidean3.prototype.rshift = function (rhs) {
var coord, pack;
coord = function (x, n) {
return x[n];
};
pack = function (w, x, y, z, xy, yz, zx, xyz) {
return Euclidean3.fromCartesian(w, x, y, z, xy, yz, zx, xyz);
};
return compute(rcoE3, [this.w, this.x, this.y, this.z, this.xy, this.yz, this.zx, this.xyz], [rhs.w, rhs.x, rhs.y, rhs.z, rhs.xy, rhs.yz, rhs.zx, rhs.xyz], coord, pack);
};
Euclidean3.prototype.grade = function (index) {
switch (index) {
case 0:
return Euclidean3.fromCartesian(this.w, 0, 0, 0, 0, 0, 0, 0);
case 1:
return Euclidean3.fromCartesian(0, this.x, this.y, this.z, 0, 0, 0, 0);
case 2:
return Euclidean3.fromCartesian(0, 0, 0, 0, this.xy, this.yz, this.zx, 0);
case 3:
return Euclidean3.fromCartesian(0, 0, 0, 0, 0, 0, 0, this.xyz);
default:
return Euclidean3.fromCartesian(0, 0, 0, 0, 0, 0, 0, 0);
}
};
Euclidean3.prototype.dot = function (vector) {
return this.x * vector.x + this.y * vector.y + this.z * vector.z;
};
Euclidean3.prototype.cross = function (vector) {
var x, x1, x2, y, y1, y2, z, z1, z2;
x1 = this.x;
y1 = this.y;
z1 = this.z;
x2 = vector.x;
y2 = vector.y;
z2 = vector.z;
x = y1 * z2 - z1 * y2;
y = z1 * x2 - x1 * z2;
z = x1 * y2 - y1 * x2;
return new Euclidean3(0, x, y, z, 0, 0, 0, 0);
};
Euclidean3.prototype.length = function () {
return Math.sqrt(this.w * this.w + this.x * this.x + this.y * this.y + this.z * this.z + this.xy * this.xy + this.yz * this.yz + this.zx * this.zx + this.xyz * this.xyz);
};
Euclidean3.prototype.norm = function () {
return new Euclidean3(Math.sqrt(this.w * this.w + this.x * this.x + this.y * this.y + this.z * this.z + this.xy * this.xy + this.yz * this.yz + this.zx * this.zx + this.xyz * this.xyz), 0, 0, 0, 0, 0, 0, 0);
};
Euclidean3.prototype.quad = function () {
return new Euclidean3(this.w * this.w + this.x * this.x + this.y * this.y + this.z * this.z + this.xy * this.xy + this.yz * this.yz + this.zx * this.zx + this.xyz * this.xyz, 0, 0, 0, 0, 0, 0, 0);
};
Euclidean3.prototype.sqrt = function () {
return new Euclidean3(Math.sqrt(this.w), 0, 0, 0, 0, 0, 0, 0);
};
Euclidean3.prototype.toString = function () {
return stringFromCoordinates([this.w, this.x, this.y, this.z, this.xy, this.yz, this.zx, this.xyz], ["1", "e1", "e2", "e3", "e12", "e23", "e31", "e123"]);
};
Euclidean3.prototype.toStringIJK = function () {
return stringFromCoordinates([this.w, this.x, this.y, this.z, this.xy, this.yz, this.zx, this.xyz], ["1", "i", "j", "k", "ij", "jk", "ki", "I"]);
};
Euclidean3.prototype.toStringLATEX = function () {
return stringFromCoordinates([this.w, this.x, this.y, this.z, this.xy, this.yz, this.zx, this.xyz], ["1", "e_{1}", "e_{2}", "e_{3}", "e_{12}", "e_{23}", "e_{31}", "e_{123}"]);
};
return Euclidean3;
})();
return Euclidean3;
});
