mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-08-14 17:58:59 +00:00
838e7d5381
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@5282 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
378 lines
9.4 KiB
JavaScript
378 lines
9.4 KiB
JavaScript
/*
|
|
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");
|
|
|
|
// some of this code is based on
|
|
// http://www.mkaz.com/math/MatrixCalculator.java
|
|
// (published under a BSD Open Source License)
|
|
//
|
|
// the rest is from my vague memory of matricies in school [cal]
|
|
//
|
|
// the copying of arguments is a little excessive, and could be trimmed back in
|
|
// the case where a function doesn't modify them at all (but some do!)
|
|
//
|
|
// 2006-06-25: Some enhancements submitted by Erel Segal:
|
|
// * addition: a tolerance constant for determinant calculations.
|
|
// * performance fix: removed unnecessary argument copying.
|
|
// * addition: function "product" for multiplying more than 2 matrices
|
|
// * addition: function "sum" for adding any number of matrices
|
|
// * bug fix: inversion of a 1x1 matrix without using the adjoint
|
|
// * performance fixes: upperTriangle
|
|
// * addition: argument "value" to function create, to initialize the matrix with a custom val
|
|
// * addition: functions "ones" and "zeros" - like Matlab[TM] functions with the same name.
|
|
// * addition: function "identity" for creating an identity matrix of a given size.
|
|
// * addition: argument "decimal_points" to function format
|
|
// * bug fix: adjoint of a 0-size matrix
|
|
// * performance fixes: adjoint
|
|
//
|
|
|
|
dojo.math.matrix.iDF = 0;
|
|
|
|
// Erel: values lower than this value are considered zero (in detereminant calculations).
|
|
// It is analogous to Maltab[TM]'s "eps".
|
|
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;
|
|
}
|
|
|
|
// Erel: added a "product" function to calculate product of more than 2 matrices:
|
|
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;
|
|
}
|
|
|
|
// Erel: added a "sum" function to calculate sum of more than 2 matrices:
|
|
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;
|
|
}
|
|
|
|
// The actual addition:
|
|
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){
|
|
// Erel: added special case: inverse of a 1x1 matrix can't be calculated by adjoint
|
|
if (a.length==1 && a[0].length==1){
|
|
return [[ 1 / a[0][0] ]];
|
|
}
|
|
|
|
// Formula used to Calculate Inverse:
|
|
// inv(A) = 1/det(A) * adj(A)
|
|
|
|
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); // Copy m, because m is changed!
|
|
var f1 = 0;
|
|
var temp = 0;
|
|
var tms = m.length;
|
|
var v = 1;
|
|
|
|
//Erel: why use a global variable and not a local variable?
|
|
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;
|
|
|
|
// check if there is a 0 in diagonal
|
|
while ((m[col][col] == 0) && !stop_loop) {
|
|
// if so, switch rows until there is no 0 in diagonal:
|
|
if (col + v >= tms){
|
|
// check if switched all rows
|
|
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]; // switch rows
|
|
m[col + v][r] = temp;
|
|
}
|
|
v++; // count row switchs
|
|
dojo.math.matrix.iDF *= -1; // each switch changes determinant factor
|
|
}
|
|
}
|
|
|
|
// loop over lower-right triangle (where row>col):
|
|
// for each row, make m[row][col] = 0 by linear operations that don't change the determinant:
|
|
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];
|
|
// this should make m[row][col] zero:
|
|
// m[row] += f1 * m[col];
|
|
for (var i = col; i < tms; i++) {
|
|
m[row][i] = f1 * m[col][i] + m[row][i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return m;
|
|
}
|
|
|
|
// Erel: added parameter "value" - a custom default value to fill the matrix with.
|
|
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;
|
|
}
|
|
|
|
// Erel implement Matlab[TM] functions "ones" and "zeros"
|
|
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);
|
|
}
|
|
|
|
// Erel: added function that returns identity matrix.
|
|
// size = number of rows and cols in the matrix.
|
|
// scale = an optional value to multiply the matrix by (default is 1).
|
|
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;
|
|
|
|
// Erel: added "<=" to catch zero-size matrix
|
|
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++) { // create a temporary matrix for determinant calc
|
|
if (ii==i){
|
|
continue; // skip current row
|
|
}
|
|
ja = 0;
|
|
for (jj = 0; jj < tms; jj++) {
|
|
if (jj==j){
|
|
continue; // skip current col
|
|
}
|
|
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;
|
|
}
|
|
|
|
// Erel: added decimal_points argument
|
|
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); // Copy a because a is changed!
|
|
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;
|
|
}
|