litvinovg/vitro
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Improve output: distinguish between failed assertions (failures) and unexpected exceptions (errors), and print a filtered stack trace for any exception.

Browse source
This commit is contained in:
jeb228 2010-01-29 22:13:57 +00:00
commit 4f2e303079
1839 changed files with 235630 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

12
webapp/web/src/math/Math.js Normal file
View file

@ -0,0 +1,12 @@
/*
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.deprecated("dojo.math.Math", "include dojo.math instead", "0.4");
dojo.require("dojo.math");

18
webapp/web/src/math/__package__.js Normal file
View file

@ -0,0 +1,18 @@
/*
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.kwCompoundRequire({
common: [
["dojo.math", false, false],
["dojo.math.curves", false, false],
["dojo.math.points", false, false]
]
});
dojo.provide("dojo.math.*");

222
webapp/web/src/math/curves.js Normal file
View file

@ -0,0 +1,222 @@
/*
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.curves");
dojo.require("dojo.math");
/* Curves from Dan's 13th lib stuff.
* See: http://pupius.co.uk/js/Toolkit.Drawing.js
* http://pupius.co.uk/dump/dojo/Dojo.Math.js
*/
dojo.math.curves = {
//Creates a straight line object
Line: function(start, end) {
this.start = start;
this.end = end;
this.dimensions = start.length;
for(var i = 0; i < start.length; i++) {
start[i] = Number(start[i]);
}
for(var i = 0; i < end.length; i++) {
end[i] = Number(end[i]);
}
//simple function to find point on an n-dimensional, straight line
this.getValue = function(n) {
var retVal = new Array(this.dimensions);
for(var i=0;i<this.dimensions;i++)
retVal[i] = ((this.end[i] - this.start[i]) * n) + this.start[i];
return retVal;
}
return this;
},
//Takes an array of points, the first is the start point, the last is end point and the ones in
//between are the Bezier control points.
Bezier: function(pnts) {
this.getValue = function(step) {
if(step >= 1) return this.p[this.p.length-1]; // if step>=1 we must be at the end of the curve
if(step <= 0) return this.p[0]; // if step<=0 we must be at the start of the curve
var retVal = new Array(this.p[0].length);
for(var k=0;j<this.p[0].length;k++) { retVal[k]=0; }
for(var j=0;j<this.p[0].length;j++) {
var C=0; var D=0;
for(var i=0;i<this.p.length;i++) {
C += this.p[i][j] * this.p[this.p.length-1][0]
* dojo.math.bernstein(step,this.p.length,i);
}
for(var l=0;l<this.p.length;l++) {
D += this.p[this.p.length-1][0] * dojo.math.bernstein(step,this.p.length,l);
}
retVal[j] = C/D;
}
return retVal;
}
this.p = pnts;
return this;
},
//Catmull-Rom Spline - allows you to interpolate a smooth curve through a set of points in n-dimensional space
CatmullRom : function(pnts,c) {
this.getValue = function(step) {
var percent = step * (this.p.length-1);
var node = Math.floor(percent);
var progress = percent - node;
var i0 = node-1; if(i0 < 0) i0 = 0;
var i = node;
var i1 = node+1; if(i1 >= this.p.length) i1 = this.p.length-1;
var i2 = node+2; if(i2 >= this.p.length) i2 = this.p.length-1;
var u = progress;
var u2 = progress*progress;
var u3 = progress*progress*progress;
var retVal = new Array(this.p[0].length);
for(var k=0;k<this.p[0].length;k++) {
var x1 = ( -this.c * this.p[i0][k] ) + ( (2 - this.c) * this.p[i][k] ) + ( (this.c-2) * this.p[i1][k] ) + ( this.c * this.p[i2][k] );
var x2 = ( 2 * this.c * this.p[i0][k] ) + ( (this.c-3) * this.p[i][k] ) + ( (3 - 2 * this.c) * this.p[i1][k] ) + ( -this.c * this.p[i2][k] );
var x3 = ( -this.c * this.p[i0][k] ) + ( this.c * this.p[i1][k] );
var x4 = this.p[i][k];
retVal[k] = x1*u3 + x2*u2 + x3*u + x4;
}
return retVal;
}
if(!c) this.c = 0.7;
else this.c = c;
this.p = pnts;
return this;
},
// FIXME: This is the bad way to do a partial-arc with 2 points. We need to have the user
// supply the radius, otherwise we always get a half-circle between the two points.
Arc : function(start, end, ccw) {
var center = dojo.math.points.midpoint(start, end);
var sides = dojo.math.points.translate(dojo.math.points.invert(center), start);
var rad = Math.sqrt(Math.pow(sides[0], 2) + Math.pow(sides[1], 2));
var theta = dojo.math.radToDeg(Math.atan(sides[1]/sides[0]));
if( sides[0] < 0 ) {
theta -= 90;
} else {
theta += 90;
}
dojo.math.curves.CenteredArc.call(this, center, rad, theta, theta+(ccw?-180:180));
},
// Creates an arc object, with center and radius (Top of arc = 0 degrees, increments clockwise)
// center => 2D point for center of arc
// radius => scalar quantity for radius of arc
// start => to define an arc specify start angle (default: 0)
// end => to define an arc specify start angle
CenteredArc : function(center, radius, start, end) {
this.center = center;
this.radius = radius;
this.start = start || 0;
this.end = end;
this.getValue = function(n) {
var retVal = new Array(2);
var theta = dojo.math.degToRad(this.start+((this.end-this.start)*n));
retVal[0] = this.center[0] + this.radius*Math.sin(theta);
retVal[1] = this.center[1] - this.radius*Math.cos(theta);
return retVal;
}
return this;
},
// Special case of Arc (start = 0, end = 360)
Circle : function(center, radius) {
dojo.math.curves.CenteredArc.call(this, center, radius, 0, 360);
return this;
},
Path : function() {
var curves = [];
var weights = [];
var ranges = [];
var totalWeight = 0;
this.add = function(curve, weight) {
if( weight < 0 ) { dojo.raise("dojo.math.curves.Path.add: weight cannot be less than 0"); }
curves.push(curve);
weights.push(weight);
totalWeight += weight;
computeRanges();
}
this.remove = function(curve) {
for(var i = 0; i < curves.length; i++) {
if( curves[i] == curve ) {
curves.splice(i, 1);
totalWeight -= weights.splice(i, 1)[0];
break;
}
}
computeRanges();
}
this.removeAll = function() {
curves = [];
weights = [];
totalWeight = 0;
}
this.getValue = function(n) {
var found = false, value = 0;
for(var i = 0; i < ranges.length; i++) {
var r = ranges[i];
//w(r.join(" ... "));
if( n >= r[0] && n < r[1] ) {
var subN = (n - r[0]) / r[2];
value = curves[i].getValue(subN);
found = true;
break;
}
}
// FIXME: Do we want to assume we're at the end?
if( !found ) {
value = curves[curves.length-1].getValue(1);
}
for(var j = 0; j < i; j++) {
value = dojo.math.points.translate(value, curves[j].getValue(1));
}
return value;
}
function computeRanges() {
var start = 0;
for(var i = 0; i < weights.length; i++) {
var end = start + weights[i] / totalWeight;
var len = end - start;
ranges[i] = [start, end, len];
start = end;
}
}
return this;
}
};

305
webapp/web/src/math/matrix.js Normal file
View file

@ -0,0 +1,305 @@
/*
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!)
//
dojo.math.matrix.iDF = 0;
dojo.math.matrix.multiply = function(a, b){
a = dojo.math.matrix.copy(a);
b = dojo.math.matrix.copy(b);
var ax = a[0].length;
var ay = a.length;
var bx = b[0].length;
var by = b.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.inverse = function(a){
a = dojo.math.matrix.copy(a);
// 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){
a = dojo.math.matrix.copy(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++){
det *= b[i][i];
}
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++) {
for (var row = col + 1; row < tms; row++) {
v = 1;
var stop_loop = 0;
// check if 0 in diagonal
while ((m[col][col] == 0) && !stop_loop){
// if so switch until not
if (col + v >= tms){
// check if switched all rows
dojo.math.matrix.iDF = 0;
stop_loop = 1;
}else{
for (var c = 0; c < tms; c++) {
temp = m[col][c];
m[col][c] = m[col + v][c]; // switch rows
m[col + v][c] = temp;
}
v++; // count row switchs
dojo.math.matrix.iDF *= -1; // each switch changes determinant factor
}
}
if (m[col][col] != 0) {
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){
var m = [];
for(var i=0; i<b; i++){
m[i] = [];
for(var j=0; j<a; j++){
m[i][j] = 0;
}
}
return m;
}
dojo.math.matrix.adjoint = function(a){
a = dojo.math.matrix.copy(a);
var tms = a.length;
if (a.length != a[0].length){
dojo.debug("Can't find the adjoint of a non-square matrix");
return [[0]];
}
if (tms == 1){
dojo.debug("Can't find the adjoint of a 1x1 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;
for (var i = 0; i < tms; i++){
for (var j = 0; j < tms; j++){
ia = 0;
ja = 0;
var ap = dojo.math.matrix.create(tms-1, tms-1);
for (ii = 0; ii < tms; ii++) {
for (jj = 0; jj < tms; jj++) {
if ((ii != i) && (jj != j)) {
ap[ia][ja] = a[ii][jj];
ja++;
}
}
if ((ii != i) && (jj != j)) {
ia++;
}
ja = 0;
}
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){
a = dojo.math.matrix.copy(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){
function format_int(x){
var dp = 5;
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 = a[0].length;
var buffer = '';
for (var y=0; y<ya; y++){
buffer += '| ';
for (var x=0; x<xa; x++){
buffer += format_int(a[y][x]) + ' ';
}
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;
}

47
webapp/web/src/math/points.js Normal file
View file

@ -0,0 +1,47 @@
/*
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.points");
dojo.require("dojo.math");
// TODO: add a Point class?
dojo.math.points = {
translate: function(a, b) {
if( a.length != b.length ) {
dojo.raise("dojo.math.translate: points not same size (a:[" + a + "], b:[" + b + "])");
}
var c = new Array(a.length);
for(var i = 0; i < a.length; i++) {
c[i] = a[i] + b[i];
}
return c;
},
midpoint: function(a, b) {
if( a.length != b.length ) {
dojo.raise("dojo.math.midpoint: points not same size (a:[" + a + "], b:[" + b + "])");
}
var c = new Array(a.length);
for(var i = 0; i < a.length; i++) {
c[i] = (a[i] + b[i]) / 2;
}
return c;
},
invert: function(a) {
var b = new Array(a.length);
for(var i = 0; i < a.length; i++) { b[i] = -a[i]; }
return b;
},
distance: function(a, b) {
return Math.sqrt(Math.pow(b[0]-a[0], 2) + Math.pow(b[1]-a[1], 2));
}
};