if (!dojo._hasResource["dojox.math.matrix"]) { // _hasResource checks added by
												// build. Do not use
												// _hasResource directly in your
												// code.
	dojo._hasResource["dojox.math.matrix"] = true;
	dojo.provide("dojox.math.matrix");

	dojo.mixin(dojox.math.matrix, {
		iDF : 0,
		ALMOST_ZERO : 1e-10,
		multiply : function(/* Array */a, /* Array */b) {
			// summary
			// Multiply matrix a by matrix b.
			var ay = a.length, ax = a[0].length, by = b.length, bx = b[0].length;
			if (ax != by) {
				console.warn("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; // Array
		},
		product : function(/* Array... */) {
			// summary
			// Return the product of N matrices
			if (arguments.length == 0) {
				console.warn("can't multiply 0 matrices!");
				return 1;
			}
			var m = arguments[0];
			for (var i = 1; i < arguments.length; i++) {
				m = this.multiply(m, arguments[i]);
			}
			return m; // Array
		},
		sum : function(/* Array... */) {
			// summary
			// Return the sum of N matrices
			if (arguments.length == 0) {
				console.warn("can't sum 0 matrices!");
				return 0; // Number
			}
			var m = this.copy(arguments[0]);
			var rows = m.length;
			if (rows == 0) {
				console.warn("can't deal with matrices of 0 rows!");
				return 0;
			}
			var cols = m[0].length;
			if (cols == 0) {
				console.warn("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) {
					console
							.warn("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++) {
						m[r][c] += arg[r][c];
					}
				}
			}
			return m; // Array
		},
		inverse : function(/* Array */a) {
			// summary
			// Return the inversion of the passed matrix
			if (a.length == 1 && a[0].length == 1) {
				return [[1 / a[0][0]]]; // Array
			}
			var tms = a.length, m = this.create(tms, tms), mm = this.adjoint(a), det = this
					.determinant(a), dd = 0;
			if (det == 0) {
				console.warn("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; // Array
		},
		determinant : function(/* Array */a) {
			// summary
			// Calculate the determinant of the passed square matrix.
			if (a.length != a[0].length) {
				console
						.warn("Can't calculate the determinant of a non-squre matrix!");
				return 0;
			}
			var tms = a.length, det = 1, b = this.upperTriangle(a);
			for (var i = 0; i < tms; i++) {
				var bii = b[i][i];
				if (Math.abs(bii) < this.ALMOST_ZERO) {
					return 0; // Number
				}
				det *= bii;
			}
			det *= this.iDF;
			return det; // Number
		},
		upperTriangle : function(/* Array */m) {
			// Summary
			// Find the upper triangle of the passed matrix and return it.
			m = this.copy(m);
			var f1 = 0, temp = 0, tms = m.length, v = 1;
			this.iDF = 1;
			for (var col = 0; col < tms - 1; col++) {
				if (typeof m[col][col] != "number") {
					console
							.warn("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) {
						this.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++;
						this.iDF *= -1;
					}
				}
				for (var row = col + 1; row < tms; row++) {
					if (typeof m[row][col] != "number") {
						console
								.warn("non-numeric entry found in a numeric matrix: m["
										+ row + "][" + col + "]=" + m[row][col]);
					}
					if (typeof m[col][row] != "number") {
						console
								.warn("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; // Array
		},
		create : function(/* Number */a, /* Number */b, /* Number? */value) {
			// summary
			// Create a new matrix with rows a and cols b, and pre-populate with
			// value.
			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; // Array
		},
		ones : function(/* Number */a, /* Number */b) {
			// summary
			// Create a matrix pre-populated with ones
			return this.create(a, b, 1); // Array
		},
		zeros : function(/* Number */a, /* Number */b) {
			// summary
			// Create a matrix pre-populated with zeros
			return this.create(a, b); // Array
		},
		identity : function(/* Number */size, /* Number? */scale) {
			// summary
			// Create an identity matrix based on the size and scale.
			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; // Array
		},
		adjoint : function(/* Array */a) {
			// summary
			// Find the adjoint of the passed matrix
			var tms = a.length;
			if (tms <= 1) {
				console
						.warn("Can't find the adjoint of a matrix with a dimension less than 2");
				return [[0]];
			}
			if (a.length != a[0].length) {
				console.warn("Can't find the adjoint of a non-square matrix");
				return [[0]];
			}
			var m = this.create(tms, tms), ap = this.create(tms - 1, tms - 1);
			var ii = 0, jj = 0, ia = 0, ja = 0, det = 0;
			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 = this.determinant(ap);
					m[i][j] = Math.pow(-1, (i + j)) * det;
				}
			}
			return this.transpose(m); // Array
		},
		transpose : function(/* Array */a) {
			// summary
			// Transpose the passed matrix (i.e. rows to columns)
			var m = this.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; // Array
		},
		format : function(/* Array */a, /* Number? */points) {
			// summary
			// Return a string representation of the matrix, rounded to points
			// (if needed)
			points = 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;
				}
				if (b.indexOf(".") > -1) {
					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], points) + " ";
				}
				buffer += "|\n";
			}
			return buffer; // string
		},
		copy : function(/* Array */a) {
			// summary
			// Create a copy of the passed matrix
			var ya = a.length, xa = a[0].length, m = this.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; // Array
		},
		scale : function(/* Array */a, /* Number */factor) {
			// summary
			// Create a copy of passed matrix and scale each member by factor.
			a = this.copy(a);
			var ya = a.length, xa = a[0].length;
			for (var y = 0; y < ya; y++) {
				for (var x = 0; x < xa; x++) {
					a[y][x] *= factor;
				}
			}
			return a;
		}
	});

}