define("gallery/mathjs/0.9.0/math-debug", [], function(require, exports, module) {

/**

* math.js

* https://github.com/josdejong/mathjs

*

* Math.js is an extensive math library for JavaScript and Node.js,

* It features real and complex numbers, units, matrices, a large set of

* mathematical functions, and a flexible expression parser.

*

* @version 0.9.0

* @date 2013-05-29

*

* @license

* Copyright (C) 2013 Jos de Jong <wjosdejong@gmail.com>

*

* Licensed under the Apache License, Version 2.0 (the "License"); you may not

* use this file except in compliance with the License. You may obtain a copy

* of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT

* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the

* License for the specific language governing permissions and limitations under

* the License.

*/

(function() {

// TODO: put "use strict"; here (but right now webstorms inspector starts

// complaining on this issue: http://youtrack.jetbrains.com/issue/WEB-7485)

/**

* Define namespace

*/

var math = {

type: {},

expr: {

node: {}

},

options: {

precision: 5

}

};

/**

* CommonJS module exports

*/

if (typeof module !== "undefined" && typeof module.exports !== "undefined") {

module.exports = math;

}

if (typeof exports !== "undefined") {

exports = math;

}

/**

* AMD module exports

*/

if (typeof require != "undefined" && typeof define != "undefined") {

define(function() {

return math;

});

}

/**

* Browser exports

*/

if (typeof window != "undefined") {

window["math"] = math;

}

// utility methods for strings, objects, and arrays

var util = function() {

var util = {};

/**

* Convert a number to a formatted string representation.

* @param {Number} value The value to be formatted

* @param {Number} [digits] number of digits

* @return {String} formattedValue The formatted value

*/

util.formatNumber = function formatNumber(value, digits) {

if (value === Infinity) {

return "Infinity";

} else if (value === -Infinity) {

return "-Infinity";

} else if (value === NaN) {

return "NaN";

}

// TODO: what is a nice limit for non-scientific values?

var abs = Math.abs(value);

if (abs > .001 && abs < 1e5 || abs == 0) {

// round the value to a limited number of digits

return util.toPrecision(value, digits);

} else {

// scientific notation

var exp = Math.round(Math.log(abs) / Math.LN10);

var v = value / Math.pow(10, exp);

return util.toPrecision(v, digits) + "e" + exp;

}

};

/**

* Round a value to a maximum number of digits. Trailing zeros will be

* removed.

* @param {Number} value

* @param {Number} [digits]

* @returns {string} str

*/

util.toPrecision = function(value, digits) {

return value.toPrecision(digits).replace(_trailingZeros, function(a, b, c) {

return a.substring(0, a.length - (b.length ? 0 : 1) - c.length);

});

};

/** @private */

var _trailingZeros = /\.(\d*?)(0+)$/g;

/**

* Recursively format an n-dimensional matrix

* Example output: "[[1, 2], [3, 4]]"

* @param {Array} array

* @returns {String} str

*/

util.formatArray = function formatArray(array) {

if (array instanceof Array) {

var str = "[";

var len = array.length;

for (var i = 0; i < len; i++) {

if (i != 0) {

str += ", ";

}

str += util.formatArray(array[i]);

}

str += "]";

return str;

} else {

return math.format(array);

}

};

/**

* Recursively format an n-dimensional array, output looks like

* "[1, 2, 3]"

* @param {Array} array

* @returns {string} str

*/

util.formatArray2d = function formatArray2d(array) {

var str = "[";

var s = util.size(array);

if (s.length != 2) {

throw new RangeError("Array must be two dimensional (size: " + util.formatArray(s) + ")");

}

var rows = s[0];

var cols = s[1];

for (var r = 0; r < rows; r++) {

if (r != 0) {

str += "; ";

}

var row = array[r];

for (var c = 0; c < cols; c++) {

if (c != 0) {

str += ", ";

}

var cell = row[c];

if (cell != undefined) {

str += math.format(cell);

}

}

}

str += "]";

return str;

};

/**

* Convert function arguments to an array. Arguments can have the following

* signature:

* fn()

* fn(n)

* fn(m, n, p, ...)

* fn([m, n, p, ...])

* @param {...Number | Array | Matrix} args

* @returns {Array} array

*/

util.argsToArray = function argsToArray(args) {

var array;

if (args.length == 0) {

// fn()

array = [];

} else if (args.length == 1) {

// fn(n)

// fn([m, n, p, ...])

array = args[0];

if (array instanceof Matrix) {

array = array.toVector();

}

if (array instanceof Range) {

array = array.valueOf();

}

if (!(array instanceof Array)) {

array = [ array ];

}

} else {

// fn(m, n, p, ...)

array = [];

for (var i = 0; i < args.length; i++) {

array[i] = args[i];

}

}

return array;

};

/**

* Check if a text ends with a certain string.

* @param {String} text

* @param {String} search

*/

util.endsWith = function(text, search) {

var start = text.length - search.length;

var end = text.length;

return text.substring(start, end) === search;

};

/**

* Extend object a with the properties of object b

* @param {Object} a

* @param {Object} b

* @return {Object} a

*/

util.extend = function(a, b) {

for (var prop in b) {

if (b.hasOwnProperty(prop)) {

a[prop] = b[prop];

}

}

return a;

};

/**

* Create a semi UUID

* source: http://stackoverflow.com/a/105074/1262753

* @return {String} uuid

*/

util.randomUUID = function randomUUID() {

var S4 = function() {

return Math.floor(Math.random() * 65536).toString(16);

};

return S4() + S4() + "-" + S4() + "-" + S4() + "-" + S4() + "-" + S4() + S4() + S4();

};

/**

* Execute function fn element wise for each element in array.

* Returns an array with the results

* @param {Array | Matrix | Range} array

* @param {function} fn

* @return {Array | Matrix} res

*/

util.map = function map(array, fn) {

if (array instanceof Array || array instanceof Matrix || array instanceof Range) {

return array.map(function(x) {

return fn(x);

});

} else {

throw new TypeError("Array expected");

}

};

/**

* Execute function fn element wise for each entry in two given arrays, or

* for a (scalar) object and array pair. Returns an array with the results

* @param {Array | Matrix | Range | Object} array1

* @param {Array | Matrix | Range | Object} array2

* @param {function} fn

* @return {Array | Matrix} res

*/

util.map2 = function map2(array1, array2, fn) {

var res, len, i;

// handle Matrix

if (array1 instanceof Matrix || array2 instanceof Matrix) {

return new Matrix(util.map2(array1.valueOf(), array2.valueOf(), fn));

}

// handle Range

if (array1 instanceof Range || array2 instanceof Range) {

// TODO: util.map2 does not utilize Range.map

return util.map2(array1.valueOf(), array2.valueOf(), fn);

}

if (array1 instanceof Array) {

if (array2 instanceof Array) {

// fn(array, array)

if (array1.length != array2.length) {

throw new RangeError("Dimension mismatch " + "(" + array1.length + " != " + array2.length + ")");

}

res = [];

len = array1.length;

for (i = 0; i < len; i++) {

res[i] = fn(array1[i], array2[i]);

}

} else {

// fn(array, object)

res = [];

len = array1.length;

for (i = 0; i < len; i++) {

res[i] = fn(array1[i], array2);

}

}

} else {

if (array2 instanceof Array) {

// fn(object, array)

res = [];

len = array2.length;

for (i = 0; i < len; i++) {

res[i] = fn(array1, array2[i]);

}

} else {

// fn(object, object)

res = fn(array1, array2);

}

}

return res;

};

/**

* For each method for objects and arrays.

* In case of an object, the method loops over all properties of the object.

* In case of an array, the method loops over all indexes of the array.

* @param {Object | Array} object The object

* @param {function} callback Callback method, called for each item in

* the object or array with three parameters:

* callback(value, index, object)

*/

util.forEach = function forEach(object, callback) {

if (object instanceof Array) {

object.forEach(callback);

} else {

for (var key in object) {

if (object.hasOwnProperty(key)) {

callback(object[key], key, object);

}

}

}

};

/**

* Creates a new object with the results of calling a provided function on

* every property in the object.

* @param {Object} object The object.

* @param {function} callback Mapping function

* @return {Object | Array} mappedObject

*/

util.mapObject = function mapObject(object, callback) {

var m = {};

for (var key in object) {

if (object.hasOwnProperty(key)) {

m[key] = callback(object[key]);

}

}

return m;

};

/**

* Deep test equality of all fields in two pairs of arrays or objects.

* @param {Array | Object} a

* @param {Array | Object} b

* @returns {boolean}

*/

util.deepEqual = function(a, b) {

var prop, i, len;

if (a instanceof Array) {

if (!(b instanceof Array)) {

return false;

}

for (i = 0, len = a.length; i < len; i++) {

if (!util.deepEqual(a[i], b[i])) {

return false;

}

}

return true;

} else if (a instanceof Object) {

if (b instanceof Array || !(b instanceof Object)) {

return false;

}

for (prop in a) {

if (a.hasOwnProperty(prop)) {

if (!util.deepEqual(a[prop], b[prop])) {

return false;

}

}

}

for (prop in b) {

if (b.hasOwnProperty(prop)) {

if (!util.deepEqual(a[prop], b[prop])) {

return false;

}

}

}

return true;

} else {

return a.valueOf() == b.valueOf();

}

};

/**

* Recursively calculate the size of a multi dimensional array.

* @param {Array} x

* @Return {Number[]} size

* @throws RangeError

*/

function _size(x) {

if (x instanceof Array) {

var sizeX = x.length;

if (sizeX) {

var size0 = _size(x[0]);

if (size0[0] == 0) {

return [ 0 ].concat(size0);

} else {

return [ sizeX ].concat(size0);

}

} else {

return [ sizeX ];

}

} else {

return [];

}

}

/**

* Calculate the size of a multi dimensional array.

* All elements in the array are checked for matching dimensions using the

* method validate

* @param {Array} x

* @Return {Number[]} size

* @throws RangeError

*/

util.size = function size(x) {

// calculate the size

var s = _size(x);

// verify the size

util.validate(x, s);

return s;

};

/**

* Recursively validate whether each element in a multi dimensional array

* has a size corresponding to the provided size array.

* @param {Array} array Array to be validated

* @param {Number[]} size Array with the size of each dimension

* @param {Number} dim Current dimension

* @throws RangeError

*/

function _validate(array, size, dim) {

var i;

var len = array.length;

if (len != size[dim]) {

throw new RangeError("Dimension mismatch (" + len + " != " + size[dim] + ")");

}

if (dim < size.length - 1) {

// recursively validate each child array

var dimNext = dim + 1;

for (i = 0; i < len; i++) {

var child = array[i];

if (!(child instanceof Array)) {

throw new RangeError("Dimension mismatch " + "(" + (size.length - 1) + " < " + size.length + ")");

}

_validate(array[i], size, dimNext);

}

} else {

// last dimension. none of the childs may be an array

for (i = 0; i < len; i++) {

if (array[i] instanceof Array) {

throw new RangeError("Dimension mismatch " + "(" + (size.length + 1) + " > " + size.length + ")");

}

}

}

}

/**

* Recursively validate whether each array in a multi dimensional array

* is empty (zero size) and has the correct number dimensions.

* @param {Array} array Array to be validated

* @param {Number[]} size Array with the size of each dimension

* @param {Number} dim Current dimension

* @throws RangeError

*/

function _validateEmpty(array, size, dim) {

if (dim < size.length - 1) {

var child = array[0];

if (array.length != 1 || !(child instanceof Array)) {

throw new RangeError("Dimension mismatch " + "(" + array.length + " > 0)");

}

_validateEmpty(child, size, dim + 1);

} else {

// last dimension. test if empty

if (array.length) {

throw new RangeError("Dimension mismatch " + "(" + array.length + " > 0)");

}

}

}

/**

* Validate whether each element in a multi dimensional array has

* a size corresponding to the provided size array.

* @param {Array} array Array to be validated

* @param {Number[]} size Array with the size of each dimension

* @throws RangeError

*/

util.validate = function validate(array, size) {

var isScalar = size.length == 0;

if (isScalar) {

// scalar

if (array instanceof Array) {

throw new RangeError("Dimension mismatch (" + array.length + " != 0)");

}

return;

}

var hasZeros = size.indexOf(0) != -1;

if (hasZeros) {

// array where all dimensions are zero

size.forEach(function(value) {

if (value != 0) {

throw new RangeError("Invalid size, all dimensions must be " + "either zero or non-zero (size: " + util.formatArray(size) + ")");

}

});

_validateEmpty(array, size, 0);

} else {

_validate(array, size, 0);

}

};

/**

* Test whether index is an integer number with index >= 1 and index <= max

* @param {*} index One-based index

* @param {Number} [max] One-based maximum value

*/

util.validateIndex = function(index, max) {

if (!isNumber(index) || !isInteger(index)) {

throw new TypeError("Index must be an integer (value: " + index + ")");

}

if (index < 1) {

throw new RangeError("Index out of range (" + index + " < 1)");

}

if (max && index > max) {

throw new RangeError("Index out of range (" + index + " > " + max + ")");

}

};

/**

* Recursively resize a multi dimensional array

* @param {Array} array Array to be resized

* @param {Number[]} size Array with the size of each dimension

* @param {Number} dim Current dimension

* @param {*} [defaultValue] Value to be filled in in new entries,

* 0 by default.

* @private

*/

function _resize(array, size, dim, defaultValue) {

if (!(array instanceof Array)) {

throw new TypeError("Array expected");

}

var len = array.length, newLen = size[dim];

if (len != newLen) {

if (newLen > array.length) {

// enlarge

for (var i = array.length; i < newLen; i++) {

array[i] = defaultValue ? math.clone(defaultValue) : 0;

}

} else {

// shrink

array.length = size[dim];

}

len = array.length;

}

if (dim < size.length - 1) {

// recursively validate each child array

var dimNext = dim + 1;

for (i = 0; i < len; i++) {

child = array[i];

if (!(child instanceof Array)) {

child = [ child ];

array[i] = child;

}

_resize(child, size, dimNext, defaultValue);

}

} else {

// last dimension

for (i = 0; i < len; i++) {

var child = array[i];

while (child instanceof Array) {

child = child[0];

}

array[i] = child;

}

}

}

/**

* Resize a multi dimensional array

* @param {Array} array Array to be resized

* @param {Number[]} size Array with the size of each dimension

* @param {*} [defaultValue] Value to be filled in in new entries,

* 0 by default

*/

util.resize = function resize(array, size, defaultValue) {

// TODO: what to do with scalars, when size=[] ?

// check the type of size

if (!(size instanceof Array)) {

throw new TypeError("Size must be an array (size is " + math["typeof"](size) + ")");

}

// check whether size contains positive integers

size.forEach(function(value) {

if (!isNumber(value) || !isInteger(value) || value < 0) {

throw new TypeError("Invalid size, must contain positive integers " + "(size: " + util.formatArray(size) + ")");

}

});

var hasZeros = size.indexOf(0) != -1;

if (hasZeros) {

// array where all dimensions are zero

size.forEach(function(value) {

if (value != 0) {

throw new RangeError("Invalid size, all dimensions must be " + "either zero or non-zero (size: " + util.formatArray(size) + ")");

}

});

}

// recursively resize

_resize(array, size, 0, defaultValue);

};

return util;

}();

/**

* Utility functions for Booleans

*/

/**

* Test whether value is a Boolean

* @param {*} value

* @return {Boolean} isBoolean

*/

function isBoolean(value) {

return value instanceof Boolean || typeof value == "boolean";

}

/**

* @constructor Complex

*

* A complex value can be constructed in the following ways:

* var a = new Complex();

* var b = new Complex(re, im);

* var c = Complex.parse(str);

*

* Example usage:

* var a = new Complex(3, -4); // 3 - 4i

* a.re = 5; // a = 5 - 4i

* var i = a.im; // -4;

* var b = Complex.parse('2 + 6i'); // 2 + 6i

* var c = new Complex(); // 0 + 0i

* var d = math.add(a, b); // 5 + 2i

*

* @param {Number} re The real part of the complex value

* @param {Number} [im] The imaginary part of the complex value

*/

function Complex(re, im) {

if (!(this instanceof Complex)) {

throw new SyntaxError("Complex constructor must be called with the new operator");

}

if (re != null && !isNumber(re) || im != null && !isNumber(im)) {

throw new TypeError("Two numbers expected in Complex constructor");

}

this.re = re || 0;

this.im = im || 0;

}

math.type.Complex = Complex;

// Complex parser methods in a closure

(function() {

var text, index, c;

function skipWhitespace() {

while (c == " " || c == " ") {

next();

}

}

function isDigitDot(c) {

return c >= "0" && c <= "9" || c == ".";

}

function isDigit(c) {

return c >= "0" && c <= "9";

}

function next() {

index++;

c = text.charAt(index);

}

function revert(oldIndex) {

index = oldIndex;

c = text.charAt(index);

}

function parseNumber() {

var number = "";

var oldIndex;

oldIndex = index;

if (c == "+") {

next();

} else if (c == "-") {

number += c;

next();

}

if (!isDigitDot(c)) {

// a + or - must be followed by a digit

revert(oldIndex);

return null;

}

// get number, can have a single dot

if (c == ".") {

number += c;

next();

if (!isDigit(c)) {

// this is no legal number, it is just a dot

revert(oldIndex);

return null;

}

} else {

while (isDigit(c)) {

number += c;

next();

}

if (c == ".") {

number += c;

next();

}

}

while (isDigit(c)) {

number += c;

next();

}

// check for scientific notation like "2.3e-4" or "1.23e50"

if (c == "E" || c == "e") {

number += c;

next();

if (c == "+" || c == "-") {

number += c;

next();

}

// Scientific notation MUST be followed by an exponent

if (!isDigit(c)) {

// this is no legal number, exponent is missing.

revert(oldIndex);

return null;

}

while (isDigit(c)) {

number += c;

next();

}

}

return number;

}

function parseComplex() {

// check for 'i', '-i', '+i'

var cnext = text.charAt(index + 1);

if (c == "I" || c == "i") {

next();

return "1";

} else if ((c == "+" || c == "-") && (cnext == "I" || cnext == "i")) {

var number = c == "+" ? "1" : "-1";

next();

next();

return number;

}

return null;

}

/**

* Parse a complex number from a string. For example Complex.parse("2 + 3i")

* will return a Complex value where re = 2, im = 3.

* Returns null if provided string does not contain a valid complex number.

* @param {String} str

* @returns {Complex | null} complex

*/

Complex.parse = function parse(str) {

text = str;

index = -1;

c = "";

if (!isString(text)) {

return null;

}

next();

skipWhitespace();

var first = parseNumber();

if (first) {

if (c == "I" || c == "i") {

// pure imaginary number

next();

skipWhitespace();

if (c) {

// garbage at the end. not good.

return null;

}

return new Complex(0, Number(first));

} else {

// complex and real part

skipWhitespace();

var separator = c;

if (separator != "+" && separator != "-") {

// pure real number

skipWhitespace();

if (c) {

// garbage at the end. not good.

return null;

}

return new Complex(Number(first), 0);

} else {

// complex and real part

next();

skipWhitespace();

var second = parseNumber();

if (second) {

if (c != "I" && c != "i") {

// 'i' missing at the end of the complex number

return null;

}

next();

} else {

second = parseComplex();

if (!second) {

// imaginary number missing after separator

return null;

}

}

if (separator == "-") {

if (second[0] == "-") {

second = "+" + second.substring(1);

} else {

second = "-" + second;

}

}

next();

skipWhitespace();

if (c) {

// garbage at the end. not good.

return null;

}

return new Complex(Number(first), Number(second));

}

}

} else {

// check for 'i', '-i', '+i'

first = parseComplex();

if (first) {

skipWhitespace();

if (c) {

// garbage at the end. not good.

return null;

}

return new Complex(0, Number(first));

}

}

return null;

};

})();

/**

* Test whether value is a Complex value

* @param {*} value

* @return {Boolean} isComplex

*/

function isComplex(value) {

return value instanceof Complex;

}

/**

* Create a copy of the complex value

* @return {Complex} clone

*/

Complex.prototype.clone = function() {

return new Complex(this.re, this.im);

};

/**

* Get string representation of the Complex value

* @return {String} str

*/

Complex.prototype.toString = function() {

var str = "";

var strRe = util.formatNumber(this.re, math.options.precision);

var strIm = util.formatNumber(this.im, math.options.precision);

if (this.im == 0) {

// real value

str = strRe;

} else if (this.re == 0) {

// purely complex value

if (this.im == 1) {

str = "i";

} else if (this.im == -1) {

str = "-i";

} else {

str = strIm + "i";

}

} else {

// complex value

if (this.im > 0) {

if (this.im == 1) {

str = strRe + " + i";

} else {

str = strRe + " + " + strIm + "i";

}

} else {

if (this.im == -1) {

str = strRe + " - i";

} else {

str = strRe + " - " + util.formatNumber(Math.abs(this.im), math.options.precision) + "i";

}

}

}

return str;

};

/**

* @constructor Matrix

*

* A Matrix is a wrapper around an Array. A matrix can hold a multi dimensional

* array. A matrix can be constructed as:

* var matrix = new Matrix(data)

*

* Matrix contains the functions to resize, get and set values, get the size,

* clone the matrix and to convert the matrix to a vector, array, or scalar.

* Furthermore, one can iterate over the matrix using map and forEach.

* The internal Array of the Matrix can be accessed using the method valueOf.

*

* Example usage:

* var matrix = new Matrix([[1, 2], [3, 4]);

* matix.size(); // [2, 2]

* matrix.resize([3, 2], 5);

* matrix.valueOf(); // [[1, 2], [3, 4], [5, 5]]

* matrix.get([2,1]) // 3

*

* @param {Array | Matrix} [data] A multi dimensional array

*/

function Matrix(data) {

if (!(this instanceof Matrix)) {

throw new SyntaxError("Matrix constructor must be called with the new operator");

}

if (data instanceof Matrix || data instanceof Range) {

// clone data from a Matrix or Range

this._data = data.toArray();

} else if (data instanceof Array) {

// use array as is

this._data = data;

} else if (data != null) {

// unsupported type

throw new TypeError("Unsupported type of data (" + math["typeof"](data) + ")");

} else {

// nothing provided

this._data = [];

}

// verify the size of the array

this._size = util.size(this._data);

}

math.type.Matrix = Matrix;

/**

* Get a value or a submatrix of the matrix.

* @param {Array | Matrix} index One-based index

*/

Matrix.prototype.get = function(index) {

var isScalar;

if (index instanceof Matrix) {

// index is scalar when size==[n] or size==[1,1,...]

isScalar = index.size().length == 1 || !index.size().some(function(i) {

return i != 1;

});

index = index.valueOf();

} else if (index instanceof Array) {

isScalar = !index.some(function(elem) {

var size = math.size(elem);

return size.length != 0 && size != [ 1 ];

});

} else {

throw new TypeError("Invalid index");

}

if (index.length != this._size.length) {

throw new RangeError("Dimension mismatch " + "(" + index.length + " != " + this._size.length + ")");

}

if (isScalar) {

// return a single value

switch (index.length) {

case 1:

return _get(this._data, index[0]);

case 2:

return _get(_get(this._data, index[0]), index[1]);

default:

return _getScalar(this._data, index);

}

} else {

// return a submatrix

switch (index.length) {

case 1:

return new Matrix(_getSubmatrix1D(this._data, index));

case 2:

return new Matrix(_getSubmatrix2D(this._data, index));

default:

return new Matrix(_getSubmatrix(this._data, index, 0));

}

}

};

/**

* Get a single value from an array. The method tests whether:

* - index is a non-negative integer

* - index does not exceed the dimensions of array

* @param {Array} array

* @param {Number} index One-based index

* @return {*} value

* @private

*/

function _get(array, index) {

util.validateIndex(index, array.length);

return array[index - 1];

}

/**

* Get a single value from the matrix. The value will be a copy of the original

* value in the matrix.

* Index is not checked for correct number of dimensions.

* @param {Array} data

* @param {Number[]} index One-based index

* @return {*} scalar

* @private

*/

function _getScalar(data, index) {

index.forEach(function(i) {

data = _get(data, i);

});

return math.clone(data);

}

/**

* Get a submatrix of a one dimensional matrix.

* Index is not checked for correct number of dimensions.

* @param {Array} data

* @param {Array} index One-based index