8398c9048d
code was modified slightly, so the code differs from the original downloadable 1.9.5 version
290 lines
7 KiB
JavaScript
290 lines
7 KiB
JavaScript
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;
|
|
}
|
|
});
|