WebSVN – Applications.papyrus – Diff – /trunk/api/js/dojo/src/math/matrix.js


/*
	Copyright (c) 2004-2006, The Dojo Foundation
	All Rights Reserved.
 
	Licensed under the Academic Free License version 2.1 or above OR the
	modified BSD license. For more information on Dojo licensing, see:
 
		http://dojotoolkit.org/community/licensing.shtml
*/
 
 
 
dojo.provide("dojo.math.matrix");
dojo.math.matrix.iDF = 0;
dojo.math.matrix.ALMOST_ZERO = 1e-10;
dojo.math.matrix.multiply = function (a, b) {
	var ay = a.length;
	var ax = a[0].length;
	var by = b.length;
	var bx = b[0].length;
	if (ax != by) {
		dojo.debug("Can't multiply matricies of sizes " + ax + "," + ay + " and " + bx + "," + by);
		return [[0]];
	}
	var c = [];
	for (var k = 0; k < ay; k++) {
		c[k] = [];
		for (var i = 0; i < bx; i++) {
			c[k][i] = 0;
			for (var m = 0; m < ax; m++) {
				c[k][i] += a[k][m] * b[m][i];
			}
		}
	}
	return c;
};
dojo.math.matrix.product = function () {
	if (arguments.length == 0) {
		dojo.debug("can't multiply 0 matrices!");
		return 1;
	}
	var result = arguments[0];
	for (var i = 1; i < arguments.length; i++) {
		result = dojo.math.matrix.multiply(result, arguments[i]);
	}
	return result;
};
dojo.math.matrix.sum = function () {
	if (arguments.length == 0) {
		dojo.debug("can't sum 0 matrices!");
		return 0;
	}
	var result = dojo.math.matrix.copy(arguments[0]);
	var rows = result.length;
	if (rows == 0) {
		dojo.debug("can't deal with matrices of 0 rows!");
		return 0;
	}
	var cols = result[0].length;
	if (cols == 0) {
		dojo.debug("can't deal with matrices of 0 cols!");
		return 0;
	}
	for (var i = 1; i < arguments.length; ++i) {
		var arg = arguments[i];
		if (arg.length != rows || arg[0].length != cols) {
			dojo.debug("can't add matrices of different dimensions: first dimensions were " + rows + "x" + cols + ", current dimensions are " + arg.length + "x" + arg[0].length);
			return 0;
		}
		for (var r = 0; r < rows; r++) {
			for (var c = 0; c < cols; c++) {
				result[r][c] += arg[r][c];
			}
		}
	}
	return result;
};
dojo.math.matrix.inverse = function (a) {
	if (a.length == 1 && a[0].length == 1) {
		return [[1 / a[0][0]]];
	}
	var tms = a.length;
	var m = dojo.math.matrix.create(tms, tms);
	var mm = dojo.math.matrix.adjoint(a);
	var det = dojo.math.matrix.determinant(a);
	var dd = 0;
	if (det == 0) {
		dojo.debug("Determinant Equals 0, Not Invertible.");
		return [[0]];
	} else {
		dd = 1 / det;
	}
	for (var i = 0; i < tms; i++) {
		for (var j = 0; j < tms; j++) {
			m[i][j] = dd * mm[i][j];
		}
	}
	return m;
};
dojo.math.matrix.determinant = function (a) {
	if (a.length != a[0].length) {
		dojo.debug("Can't calculate the determiant of a non-squre matrix!");
		return 0;
	}
	var tms = a.length;
	var det = 1;
	var b = dojo.math.matrix.upperTriangle(a);
	for (var i = 0; i < tms; i++) {
		var bii = b[i][i];
		if (Math.abs(bii) < dojo.math.matrix.ALMOST_ZERO) {
			return 0;
		}
		det *= bii;
	}
	det = det * dojo.math.matrix.iDF;
	return det;
};
dojo.math.matrix.upperTriangle = function (m) {
	m = dojo.math.matrix.copy(m);
	var f1 = 0;
	var temp = 0;
	var tms = m.length;
	var v = 1;
	dojo.math.matrix.iDF = 1;
	for (var col = 0; col < tms - 1; col++) {
		if (typeof m[col][col] != "number") {
			dojo.debug("non-numeric entry found in a numeric matrix: m[" + col + "][" + col + "]=" + m[col][col]);
		}
		v = 1;
		var stop_loop = 0;
		while ((m[col][col] == 0) && !stop_loop) {
			if (col + v >= tms) {
				dojo.math.matrix.iDF = 0;
				stop_loop = 1;
			} else {
				for (var r = 0; r < tms; r++) {
					temp = m[col][r];
					m[col][r] = m[col + v][r];
					m[col + v][r] = temp;
				}
				v++;
				dojo.math.matrix.iDF *= -1;
			}
		}
		for (var row = col + 1; row < tms; row++) {
			if (typeof m[row][col] != "number") {
				dojo.debug("non-numeric entry found in a numeric matrix: m[" + row + "][" + col + "]=" + m[row][col]);
			}
			if (typeof m[col][row] != "number") {
				dojo.debug("non-numeric entry found in a numeric matrix: m[" + col + "][" + row + "]=" + m[col][row]);
			}
			if (m[col][col] != 0) {
				var f1 = (-1) * m[row][col] / m[col][col];
				for (var i = col; i < tms; i++) {
					m[row][i] = f1 * m[col][i] + m[row][i];
				}
			}
		}
	}
	return m;
};
dojo.math.matrix.create = function (a, b, value) {
	if (!value) {
		value = 0;
	}
	var m = [];
	for (var i = 0; i < b; i++) {
		m[i] = [];
		for (var j = 0; j < a; j++) {
			m[i][j] = value;
		}
	}
	return m;
};
dojo.math.matrix.ones = function (a, b) {
	return dojo.math.matrix.create(a, b, 1);
};
dojo.math.matrix.zeros = function (a, b) {
	return dojo.math.matrix.create(a, b, 0);
};
dojo.math.matrix.identity = function (size, scale) {
	if (!scale) {
		scale = 1;
	}
	var m = [];
	for (var i = 0; i < size; i++) {
		m[i] = [];
		for (var j = 0; j < size; j++) {
			m[i][j] = (i == j ? scale : 0);
		}
	}
	return m;
};
dojo.math.matrix.adjoint = function (a) {
	var tms = a.length;
	if (tms <= 1) {
		dojo.debug("Can't find the adjoint of a matrix with a dimension less than 2");
		return [[0]];
	}
	if (a.length != a[0].length) {
		dojo.debug("Can't find the adjoint of a non-square matrix");
		return [[0]];
	}
	var m = dojo.math.matrix.create(tms, tms);
	var ii = 0;
	var jj = 0;
	var ia = 0;
	var ja = 0;
	var det = 0;
	var ap = dojo.math.matrix.create(tms - 1, tms - 1);
	for (var i = 0; i < tms; i++) {
		for (var j = 0; j < tms; j++) {
			ia = 0;
			for (ii = 0; ii < tms; ii++) {
				if (ii == i) {
					continue;
				}
				ja = 0;
				for (jj = 0; jj < tms; jj++) {
					if (jj == j) {
						continue;
					}
					ap[ia][ja] = a[ii][jj];
					ja++;
				}
				ia++;
			}
			det = dojo.math.matrix.determinant(ap);
			m[i][j] = Math.pow(-1, (i + j)) * det;
		}
	}
	m = dojo.math.matrix.transpose(m);
	return m;
};
dojo.math.matrix.transpose = function (a) {
	var m = dojo.math.matrix.create(a.length, a[0].length);
	for (var i = 0; i < a.length; i++) {
		for (var j = 0; j < a[i].length; j++) {
			m[j][i] = a[i][j];
		}
	}
	return m;
};
dojo.math.matrix.format = function (a, decimal_points) {
	if (arguments.length <= 1) {
		decimal_points = 5;
	}
	function format_int(x, dp) {
		var fac = Math.pow(10, dp);
		var a = Math.round(x * fac) / fac;
		var b = a.toString();
		if (b.charAt(0) != "-") {
			b = " " + b;
		}
		var has_dp = 0;
		for (var i = 1; i < b.length; i++) {
			if (b.charAt(i) == ".") {
				has_dp = 1;
			}
		}
		if (!has_dp) {
			b += ".";
		}
		while (b.length < dp + 3) {
			b += "0";
		}
		return b;
	}
	var ya = a.length;
	var xa = ya > 0 ? a[0].length : 0;
	var buffer = "";
	for (var y = 0; y < ya; y++) {
		buffer += "| ";
		for (var x = 0; x < xa; x++) {
			buffer += format_int(a[y][x], decimal_points) + " ";
		}
		buffer += "|\n";
	}
	return buffer;
};
dojo.math.matrix.copy = function (a) {
	var ya = a.length;
	var xa = a[0].length;
	var m = dojo.math.matrix.create(xa, ya);
	for (var y = 0; y < ya; y++) {
		for (var x = 0; x < xa; x++) {
			m[y][x] = a[y][x];
		}
	}
	return m;
};
dojo.math.matrix.scale = function (k, a) {
	a = dojo.math.matrix.copy(a);
	var ya = a.length;
	var xa = a[0].length;
	for (var y = 0; y < ya; y++) {
		for (var x = 0; x < xa; x++) {
			a[y][x] *= k;
		}
	}
	return a;
};
 

Rev 1318	Rev 1422
1	`/*`	1	`/*`
2	`Copyright (c) 2004-2006, The Dojo Foundation`	2	`Copyright (c) 2004-2006, The Dojo Foundation`
3	`All Rights Reserved.`	3	`All Rights Reserved.`
4		4
5	`Licensed under the Academic Free License version 2.1 or above OR the`	5	`Licensed under the Academic Free License version 2.1 or above OR the`
6	`modified BSD license. For more information on Dojo licensing, see:`	6	`modified BSD license. For more information on Dojo licensing, see:`
7		7
8	`http://dojotoolkit.org/community/licensing.shtml`	8	`http://dojotoolkit.org/community/licensing.shtml`
9	`*/`	9	`*/`
-		10
-		11
10		12
11	`dojo.provide("dojo.math.matrix");`	13	`dojo.provide("dojo.math.matrix");`
12	`dojo.math.matrix.iDF = 0;`	14	`dojo.math.matrix.iDF = 0;`
13	`dojo.math.matrix.ALMOST_ZERO = 1e-10;`	15	`dojo.math.matrix.ALMOST_ZERO = 1e-10;`
14	`dojo.math.matrix.multiply = function (a, b) {`	16	`dojo.math.matrix.multiply = function (a, b) {`
15	`var ay = a.length;`	17	`var ay = a.length;`
16	`var ax = a[0].length;`	18	`var ax = a[0].length;`
17	`var by = b.length;`	19	`var by = b.length;`
18	`var bx = b[0].length;`	20	`var bx = b[0].length;`
19	`if (ax != by) {`	21	`if (ax != by) {`
20	`dojo.debug("Can't multiply matricies of sizes " + ax + "," + ay + " and " + bx + "," + by);`	22	`dojo.debug("Can't multiply matricies of sizes " + ax + "," + ay + " and " + bx + "," + by);`
21	`return [[0]];`	23	`return [[0]];`
22	`}`	24	`}`
23	`var c = [];`	25	`var c = [];`
24	`for (var k = 0; k < ay; k++) {`	26	`for (var k = 0; k < ay; k++) {`
25	`c[k] = [];`	27	`c[k] = [];`
26	`for (var i = 0; i < bx; i++) {`	28	`for (var i = 0; i < bx; i++) {`
27	`c[k][i] = 0;`	29	`c[k][i] = 0;`
28	`for (var m = 0; m < ax; m++) {`	30	`for (var m = 0; m < ax; m++) {`
29	`c[k][i] += a[k][m] * b[m][i];`	31	`c[k][i] += a[k][m] * b[m][i];`
30	`}`	32	`}`
31	`}`	33	`}`
32	`}`	34	`}`
33	`return c;`	35	`return c;`
34	`};`	36	`};`
35	`dojo.math.matrix.product = function () {`	37	`dojo.math.matrix.product = function () {`
36	`if (arguments.length == 0) {`	38	`if (arguments.length == 0) {`
37	`dojo.debug("can't multiply 0 matrices!");`	39	`dojo.debug("can't multiply 0 matrices!");`
38	`return 1;`	40	`return 1;`
39	`}`	41	`}`
40	`var result = arguments[0];`	42	`var result = arguments[0];`
41	`for (var i = 1; i < arguments.length; i++) {`	43	`for (var i = 1; i < arguments.length; i++) {`
42	`result = dojo.math.matrix.multiply(result, arguments[i]);`	44	`result = dojo.math.matrix.multiply(result, arguments[i]);`
43	`}`	45	`}`
44	`return result;`	46	`return result;`
45	`};`	47	`};`
46	`dojo.math.matrix.sum = function () {`	48	`dojo.math.matrix.sum = function () {`
47	`if (arguments.length == 0) {`	49	`if (arguments.length == 0) {`
48	`dojo.debug("can't sum 0 matrices!");`	50	`dojo.debug("can't sum 0 matrices!");`
49	`return 0;`	51	`return 0;`
50	`}`	52	`}`
51	`var result = dojo.math.matrix.copy(arguments[0]);`	53	`var result = dojo.math.matrix.copy(arguments[0]);`
52	`var rows = result.length;`	54	`var rows = result.length;`
53	`if (rows == 0) {`	55	`if (rows == 0) {`
54	`dojo.debug("can't deal with matrices of 0 rows!");`	56	`dojo.debug("can't deal with matrices of 0 rows!");`
55	`return 0;`	57	`return 0;`
56	`}`	58	`}`
57	`var cols = result[0].length;`	59	`var cols = result[0].length;`
58	`if (cols == 0) {`	60	`if (cols == 0) {`
59	`dojo.debug("can't deal with matrices of 0 cols!");`	61	`dojo.debug("can't deal with matrices of 0 cols!");`
60	`return 0;`	62	`return 0;`
61	`}`	63	`}`
62	`for (var i = 1; i < arguments.length; ++i) {`	64	`for (var i = 1; i < arguments.length; ++i) {`
63	`var arg = arguments[i];`	65	`var arg = arguments[i];`
64	`if (arg.length != rows \|\| arg[0].length != cols) {`	66	`if (arg.length != rows \|\| arg[0].length != cols) {`
65	`dojo.debug("can't add matrices of different dimensions: first dimensions were " + rows + "x" + cols + ", current dimensions are " + arg.length + "x" + arg[0].length);`	67	`dojo.debug("can't add matrices of different dimensions: first dimensions were " + rows + "x" + cols + ", current dimensions are " + arg.length + "x" + arg[0].length);`
66	`return 0;`	68	`return 0;`
67	`}`	69	`}`
68	`for (var r = 0; r < rows; r++) {`	70	`for (var r = 0; r < rows; r++) {`
69	`for (var c = 0; c < cols; c++) {`	71	`for (var c = 0; c < cols; c++) {`
70	`result[r][c] += arg[r][c];`	72	`result[r][c] += arg[r][c];`
71	`}`	73	`}`
72	`}`	74	`}`
73	`}`	75	`}`
74	`return result;`	76	`return result;`
75	`};`	77	`};`
76	`dojo.math.matrix.inverse = function (a) {`	78	`dojo.math.matrix.inverse = function (a) {`
77	`if (a.length == 1 && a[0].length == 1) {`	79	`if (a.length == 1 && a[0].length == 1) {`
78	`return [[1 / a[0][0]]];`	80	`return [[1 / a[0][0]]];`
79	`}`	81	`}`
80	`var tms = a.length;`	82	`var tms = a.length;`
81	`var m = dojo.math.matrix.create(tms, tms);`	83	`var m = dojo.math.matrix.create(tms, tms);`
82	`var mm = dojo.math.matrix.adjoint(a);`	84	`var mm = dojo.math.matrix.adjoint(a);`
83	`var det = dojo.math.matrix.determinant(a);`	85	`var det = dojo.math.matrix.determinant(a);`
84	`var dd = 0;`	86	`var dd = 0;`
85	`if (det == 0) {`	87	`if (det == 0) {`
86	`dojo.debug("Determinant Equals 0, Not Invertible.");`	88	`dojo.debug("Determinant Equals 0, Not Invertible.");`
87	`return [[0]];`	89	`return [[0]];`
88	`} else {`	90	`} else {`
89	`dd = 1 / det;`	91	`dd = 1 / det;`
90	`}`	92	`}`
91	`for (var i = 0; i < tms; i++) {`	93	`for (var i = 0; i < tms; i++) {`
92	`for (var j = 0; j < tms; j++) {`	94	`for (var j = 0; j < tms; j++) {`
93	`m[i][j] = dd * mm[i][j];`	95	`m[i][j] = dd * mm[i][j];`
94	`}`	96	`}`
95	`}`	97	`}`
96	`return m;`	98	`return m;`
97	`};`	99	`};`
98	`dojo.math.matrix.determinant = function (a) {`	100	`dojo.math.matrix.determinant = function (a) {`
99	`if (a.length != a[0].length) {`	101	`if (a.length != a[0].length) {`
100	`dojo.debug("Can't calculate the determiant of a non-squre matrix!");`	102	`dojo.debug("Can't calculate the determiant of a non-squre matrix!");`
101	`return 0;`	103	`return 0;`
102	`}`	104	`}`
103	`var tms = a.length;`	105	`var tms = a.length;`
104	`var det = 1;`	106	`var det = 1;`
105	`var b = dojo.math.matrix.upperTriangle(a);`	107	`var b = dojo.math.matrix.upperTriangle(a);`
106	`for (var i = 0; i < tms; i++) {`	108	`for (var i = 0; i < tms; i++) {`
107	`var bii = b[i][i];`	109	`var bii = b[i][i];`
108	`if (Math.abs(bii) < dojo.math.matrix.ALMOST_ZERO) {`	110	`if (Math.abs(bii) < dojo.math.matrix.ALMOST_ZERO) {`
109	`return 0;`	111	`return 0;`
110	`}`	112	`}`
111	`det *= bii;`	113	`det *= bii;`
112	`}`	114	`}`
113	`det = det * dojo.math.matrix.iDF;`	115	`det = det * dojo.math.matrix.iDF;`
114	`return det;`	116	`return det;`
115	`};`	117	`};`
116	`dojo.math.matrix.upperTriangle = function (m) {`	118	`dojo.math.matrix.upperTriangle = function (m) {`
117	`m = dojo.math.matrix.copy(m);`	119	`m = dojo.math.matrix.copy(m);`
118	`var f1 = 0;`	120	`var f1 = 0;`
119	`var temp = 0;`	121	`var temp = 0;`
120	`var tms = m.length;`	122	`var tms = m.length;`
121	`var v = 1;`	123	`var v = 1;`
122	`dojo.math.matrix.iDF = 1;`	124	`dojo.math.matrix.iDF = 1;`
123	`for (var col = 0; col < tms - 1; col++) {`	125	`for (var col = 0; col < tms - 1; col++) {`
124	`if (typeof m[col][col] != "number") {`	126	`if (typeof m[col][col] != "number") {`
125	`dojo.debug("non-numeric entry found in a numeric matrix: m[" + col + "][" + col + "]=" + m[col][col]);`	127	`dojo.debug("non-numeric entry found in a numeric matrix: m[" + col + "][" + col + "]=" + m[col][col]);`
126	`}`	128	`}`
127	`v = 1;`	129	`v = 1;`
128	`var stop_loop = 0;`	130	`var stop_loop = 0;`
129	`while ((m[col][col] == 0) && !stop_loop) {`	131	`while ((m[col][col] == 0) && !stop_loop) {`
130	`if (col + v >= tms) {`	132	`if (col + v >= tms) {`
131	`dojo.math.matrix.iDF = 0;`	133	`dojo.math.matrix.iDF = 0;`
132	`stop_loop = 1;`	134	`stop_loop = 1;`
133	`} else {`	135	`} else {`
134	`for (var r = 0; r < tms; r++) {`	136	`for (var r = 0; r < tms; r++) {`
135	`temp = m[col][r];`	137	`temp = m[col][r];`
136	`m[col][r] = m[col + v][r];`	138	`m[col][r] = m[col + v][r];`
137	`m[col + v][r] = temp;`	139	`m[col + v][r] = temp;`
138	`}`	140	`}`
139	`v++;`	141	`v++;`
140	`dojo.math.matrix.iDF *= -1;`	142	`dojo.math.matrix.iDF *= -1;`
141	`}`	143	`}`
142	`}`	144	`}`
143	`for (var row = col + 1; row < tms; row++) {`	145	`for (var row = col + 1; row < tms; row++) {`
144	`if (typeof m[row][col] != "number") {`	146	`if (typeof m[row][col] != "number") {`
145	`dojo.debug("non-numeric entry found in a numeric matrix: m[" + row + "][" + col + "]=" + m[row][col]);`	147	`dojo.debug("non-numeric entry found in a numeric matrix: m[" + row + "][" + col + "]=" + m[row][col]);`
146	`}`	148	`}`
147	`if (typeof m[col][row] != "number") {`	149	`if (typeof m[col][row] != "number") {`
148	`dojo.debug("non-numeric entry found in a numeric matrix: m[" + col + "][" + row + "]=" + m[col][row]);`	150	`dojo.debug("non-numeric entry found in a numeric matrix: m[" + col + "][" + row + "]=" + m[col][row]);`
149	`}`	151	`}`
150	`if (m[col][col] != 0) {`	152	`if (m[col][col] != 0) {`
151	`var f1 = (-1) * m[row][col] / m[col][col];`	153	`var f1 = (-1) * m[row][col] / m[col][col];`
152	`for (var i = col; i < tms; i++) {`	154	`for (var i = col; i < tms; i++) {`
153	`m[row][i] = f1 * m[col][i] + m[row][i];`	155	`m[row][i] = f1 * m[col][i] + m[row][i];`
154	`}`	156	`}`
155	`}`	157	`}`
156	`}`	158	`}`
157	`}`	159	`}`
158	`return m;`	160	`return m;`
159	`};`	161	`};`
160	`dojo.math.matrix.create = function (a, b, value) {`	162	`dojo.math.matrix.create = function (a, b, value) {`
161	`if (!value) {`	163	`if (!value) {`
162	`value = 0;`	164	`value = 0;`
163	`}`	165	`}`
164	`var m = [];`	166	`var m = [];`
165	`for (var i = 0; i < b; i++) {`	167	`for (var i = 0; i < b; i++) {`
166	`m[i] = [];`	168	`m[i] = [];`
167	`for (var j = 0; j < a; j++) {`	169	`for (var j = 0; j < a; j++) {`
168	`m[i][j] = value;`	170	`m[i][j] = value;`
169	`}`	171	`}`
170	`}`	172	`}`
171	`return m;`	173	`return m;`
172	`};`	174	`};`
173	`dojo.math.matrix.ones = function (a, b) {`	175	`dojo.math.matrix.ones = function (a, b) {`
174	`return dojo.math.matrix.create(a, b, 1);`	176	`return dojo.math.matrix.create(a, b, 1);`
175	`};`	177	`};`
176	`dojo.math.matrix.zeros = function (a, b) {`	178	`dojo.math.matrix.zeros = function (a, b) {`
177	`return dojo.math.matrix.create(a, b, 0);`	179	`return dojo.math.matrix.create(a, b, 0);`
178	`};`	180	`};`
179	`dojo.math.matrix.identity = function (size, scale) {`	181	`dojo.math.matrix.identity = function (size, scale) {`
180	`if (!scale) {`	182	`if (!scale) {`
181	`scale = 1;`	183	`scale = 1;`
182	`}`	184	`}`
183	`var m = [];`	185	`var m = [];`
184	`for (var i = 0; i < size; i++) {`	186	`for (var i = 0; i < size; i++) {`
185	`m[i] = [];`	187	`m[i] = [];`
186	`for (var j = 0; j < size; j++) {`	188	`for (var j = 0; j < size; j++) {`
187	`m[i][j] = (i == j ? scale : 0);`	189	`m[i][j] = (i == j ? scale : 0);`
188	`}`	190	`}`
189	`}`	191	`}`
190	`return m;`	192	`return m;`
191	`};`	193	`};`
192	`dojo.math.matrix.adjoint = function (a) {`	194	`dojo.math.matrix.adjoint = function (a) {`
193	`var tms = a.length;`	195	`var tms = a.length;`
194	`if (tms <= 1) {`	196	`if (tms <= 1) {`
195	`dojo.debug("Can't find the adjoint of a matrix with a dimension less than 2");`	197	`dojo.debug("Can't find the adjoint of a matrix with a dimension less than 2");`
196	`return [[0]];`	198	`return [[0]];`
197	`}`	199	`}`
198	`if (a.length != a[0].length) {`	200	`if (a.length != a[0].length) {`
199	`dojo.debug("Can't find the adjoint of a non-square matrix");`	201	`dojo.debug("Can't find the adjoint of a non-square matrix");`
200	`return [[0]];`	202	`return [[0]];`
201	`}`	203	`}`
202	`var m = dojo.math.matrix.create(tms, tms);`	204	`var m = dojo.math.matrix.create(tms, tms);`
203	`var ii = 0;`	205	`var ii = 0;`
204	`var jj = 0;`	206	`var jj = 0;`
205	`var ia = 0;`	207	`var ia = 0;`
206	`var ja = 0;`	208	`var ja = 0;`
207	`var det = 0;`	209	`var det = 0;`
208	`var ap = dojo.math.matrix.create(tms - 1, tms - 1);`	210	`var ap = dojo.math.matrix.create(tms - 1, tms - 1);`
209	`for (var i = 0; i < tms; i++) {`	211	`for (var i = 0; i < tms; i++) {`
210	`for (var j = 0; j < tms; j++) {`	212	`for (var j = 0; j < tms; j++) {`
211	`ia = 0;`	213	`ia = 0;`
212	`for (ii = 0; ii < tms; ii++) {`	214	`for (ii = 0; ii < tms; ii++) {`
213	`if (ii == i) {`	215	`if (ii == i) {`
214	`continue;`	216	`continue;`
215	`}`	217	`}`
216	`ja = 0;`	218	`ja = 0;`
217	`for (jj = 0; jj < tms; jj++) {`	219	`for (jj = 0; jj < tms; jj++) {`
218	`if (jj == j) {`	220	`if (jj == j) {`
219	`continue;`	221	`continue;`
220	`}`	222	`}`
221	`ap[ia][ja] = a[ii][jj];`	223	`ap[ia][ja] = a[ii][jj];`
222	`ja++;`	224	`ja++;`
223	`}`	225	`}`
224	`ia++;`	226	`ia++;`
225	`}`	227	`}`
226	`det = dojo.math.matrix.determinant(ap);`	228	`det = dojo.math.matrix.determinant(ap);`
227	`m[i][j] = Math.pow(-1, (i + j)) * det;`	229	`m[i][j] = Math.pow(-1, (i + j)) * det;`
228	`}`	230	`}`
229	`}`	231	`}`
230	`m = dojo.math.matrix.transpose(m);`	232	`m = dojo.math.matrix.transpose(m);`
231	`return m;`	233	`return m;`
232	`};`	234	`};`
233	`dojo.math.matrix.transpose = function (a) {`	235	`dojo.math.matrix.transpose = function (a) {`
234	`var m = dojo.math.matrix.create(a.length, a[0].length);`	236	`var m = dojo.math.matrix.create(a.length, a[0].length);`
235	`for (var i = 0; i < a.length; i++) {`	237	`for (var i = 0; i < a.length; i++) {`
236	`for (var j = 0; j < a[i].length; j++) {`	238	`for (var j = 0; j < a[i].length; j++) {`
237	`m[j][i] = a[i][j];`	239	`m[j][i] = a[i][j];`
238	`}`	240	`}`
239	`}`	241	`}`
240	`return m;`	242	`return m;`
241	`};`	243	`};`
242	`dojo.math.matrix.format = function (a, decimal_points) {`	244	`dojo.math.matrix.format = function (a, decimal_points) {`
243	`if (arguments.length <= 1) {`	245	`if (arguments.length <= 1) {`
244	`decimal_points = 5;`	246	`decimal_points = 5;`
245	`}`	247	`}`
246	`function format_int(x, dp) {`	248	`function format_int(x, dp) {`
247	`var fac = Math.pow(10, dp);`	249	`var fac = Math.pow(10, dp);`
248	`var a = Math.round(x * fac) / fac;`	250	`var a = Math.round(x * fac) / fac;`
249	`var b = a.toString();`	251	`var b = a.toString();`
250	`if (b.charAt(0) != "-") {`	252	`if (b.charAt(0) != "-") {`
251	`b = " " + b;`	253	`b = " " + b;`
252	`}`	254	`}`
253	`var has_dp = 0;`	255	`var has_dp = 0;`
254	`for (var i = 1; i < b.length; i++) {`	256	`for (var i = 1; i < b.length; i++) {`
255	`if (b.charAt(i) == ".") {`	257	`if (b.charAt(i) == ".") {`
256	`has_dp = 1;`	258	`has_dp = 1;`
257	`}`	259	`}`
258	`}`	260	`}`
259	`if (!has_dp) {`	261	`if (!has_dp) {`
260	`b += ".";`	262	`b += ".";`
261	`}`	263	`}`
262	`while (b.length < dp + 3) {`	264	`while (b.length < dp + 3) {`
263	`b += "0";`	265	`b += "0";`
264	`}`	266	`}`
265	`return b;`	267	`return b;`
266	`}`	268	`}`
267	`var ya = a.length;`	269	`var ya = a.length;`
268	`var xa = ya > 0 ? a[0].length : 0;`	270	`var xa = ya > 0 ? a[0].length : 0;`
269	`var buffer = "";`	271	`var buffer = "";`
270	`for (var y = 0; y < ya; y++) {`	272	`for (var y = 0; y < ya; y++) {`
271	`buffer += "\| ";`	273	`buffer += "\| ";`
272	`for (var x = 0; x < xa; x++) {`	274	`for (var x = 0; x < xa; x++) {`
273	`buffer += format_int(a[y][x], decimal_points) + " ";`	275	`buffer += format_int(a[y][x], decimal_points) + " ";`
274	`}`	276	`}`
275	`buffer += "\|\n";`	277	`buffer += "\|\n";`
276	`}`	278	`}`
277	`return buffer;`	279	`return buffer;`
278	`};`	280	`};`
279	`dojo.math.matrix.copy = function (a) {`	281	`dojo.math.matrix.copy = function (a) {`
280	`var ya = a.length;`	282	`var ya = a.length;`
281	`var xa = a[0].length;`	283	`var xa = a[0].length;`
282	`var m = dojo.math.matrix.create(xa, ya);`	284	`var m = dojo.math.matrix.create(xa, ya);`
283	`for (var y = 0; y < ya; y++) {`	285	`for (var y = 0; y < ya; y++) {`
284	`for (var x = 0; x < xa; x++) {`	286	`for (var x = 0; x < xa; x++) {`
285	`m[y][x] = a[y][x];`	287	`m[y][x] = a[y][x];`
286	`}`	288	`}`
287	`}`	289	`}`
288	`return m;`	290	`return m;`
289	`};`	291	`};`
290	`dojo.math.matrix.scale = function (k, a) {`	292	`dojo.math.matrix.scale = function (k, a) {`
291	`a = dojo.math.matrix.copy(a);`	293	`a = dojo.math.matrix.copy(a);`
292	`var ya = a.length;`	294	`var ya = a.length;`
293	`var xa = a[0].length;`	295	`var xa = a[0].length;`
294	`for (var y = 0; y < ya; y++) {`	296	`for (var y = 0; y < ya; y++) {`
295	`for (var x = 0; x < xa; x++) {`	297	`for (var x = 0; x < xa; x++) {`
296	`a[y][x] *= k;`	298	`a[y][x] *= k;`
297	`}`	299	`}`
298	`}`	300	`}`
299	`return a;`	301	`return a;`
300	`};`	302	`};`
301		303

Subversion Repositories Applications.papyrus

(root)/trunk/api/js/dojo/src/math/matrix.js – Rev 1318 → 1422