mirror of
https://github.com/josdejong/mathjs.git
synced 2026-01-25 15:07:57 +00:00
Changed matrix indexes from one-based to zero-based (Fixed #23)
This commit is contained in:
josdejong
parent
efbce864ad
commit
e9b9f0c4e3
@ -4,6 +4,11 @@ https://github.com/josdejong/mathjs
|
||||
|
||||
## version 0.11.0-SNAPSHOT
|
||||
|
||||
*WARNING: version 0.11 is incompatible with previous versions.*
|
||||
|
||||
- Changed math.js from one-based to zero-based indexes.
|
||||
- Getting and setting matrix subset is now zero-based.
|
||||
- The dimension argument in function `concat` is now zero-based.
|
||||
- Improvements in the string output of function help.
|
||||
- Added constants `true` and `false`.
|
||||
- Added constructor function `boolean`.
|
||||
@ -148,7 +153,7 @@ https://github.com/josdejong/mathjs
|
||||
|
||||
## 2013-04-06, version 0.5.0
|
||||
|
||||
*Note: version 0.5 is incompatible with previous versions.*
|
||||
*WARNING: version 0.5 is incompatible with previous versions.*
|
||||
|
||||
- Implemented data types Matrix and Range.
|
||||
- Implemented matrix methods clone, concat, det, diag, eye, inv, ones, size,
|
||||
|
||||
14
README.md
14
README.md
@ -392,6 +392,10 @@ A `Matrix` is an object wrapped around a regular JavaScript Array, providing
|
||||
utility methods for easy matrix manipulation such as `get`, `set`, `size`,
|
||||
`resize`, `clone`, and more.
|
||||
|
||||
Matrix indexes in math.js are zero-based, like most programming languages
|
||||
including JavaScript itself. Note that mathematical applications like Matlab
|
||||
and Octave use one-based indexes.
|
||||
|
||||
```js
|
||||
var matrix = math.matrix([1, 4, 9, 16, 25]); // Matrix, [1, 4, 9, 16, 25]
|
||||
math.sqrt(matrix); // Matrix, [1, 2, 3, 4, 5]
|
||||
@ -403,7 +407,7 @@ var a = [[1, 2], [3, 4]]; // Array, [[1, 2], [3, 4]]
|
||||
var b = math.matrix([[5, 6], [1, 1]]); // Matrix, [[5, 6], [1, 1]]
|
||||
b.set([2, [1, 2]], [[7, 8]]); // Matrix, [[5, 6], [7, 8]]
|
||||
var c = math.multiply(a, b); // Matrix, [[19, 22], [43, 50]]
|
||||
var d = c.get([2, 1]); // 43
|
||||
var d = c.get([1, 0]); // 43
|
||||
```
|
||||
|
||||
Matrices are supported by the parser:
|
||||
@ -413,11 +417,11 @@ parser = math.parser();
|
||||
|
||||
parser.eval('a = [1, 2; 3, 4]'); // Matrix, [[1, 2], [3, 4]]
|
||||
parser.eval('b = zeros(2, 2)'); // Matrix, [[0, 0], [0, 0]]
|
||||
parser.eval('b(1, 1:2) = [5, 6]'); // Matrix, [[5, 6], [0, 0]]
|
||||
parser.eval('b(2, :) = [7, 8]'); // Matrix, [[5, 6], [7, 8]]
|
||||
parser.eval('b(0, 0:1) = [5, 6]'); // Matrix, [[5, 6], [0, 0]]
|
||||
parser.eval('b(1, :) = [7, 8]'); // Matrix, [[5, 6], [7, 8]]
|
||||
parser.eval('c = a * b'); // Matrix, [[19, 22], [43, 50]]
|
||||
parser.eval('d = c(2, 1)'); // 43
|
||||
parser.eval('e = c(2, 1:end)'); // Matrix, [[43, 50]]
|
||||
parser.eval('d = c(1, 0)'); // 43
|
||||
parser.eval('e = c(1, 0:end)'); // Matrix, [[43, 50]]
|
||||
```
|
||||
|
||||
|
||||
|
||||
@ -46,11 +46,11 @@ print(math.square(selector)); // 0.44444
|
||||
// the functions get and set can be used to get or replace sub matrices
|
||||
var array = [[1, 2], [3, 4]];
|
||||
var v = math.select(array)
|
||||
.get([2, 1]);
|
||||
.get([1, 0]);
|
||||
print(v); // 3
|
||||
|
||||
var m = math.select(array)
|
||||
.set([1, 1], 8)
|
||||
.set([0, 0], 8)
|
||||
.multiply(3)
|
||||
.done();
|
||||
print(m); // [[24, 6], [9, 12]]
|
||||
|
||||
@ -43,20 +43,22 @@ print(d); // [[1, 2], [3, 4]]
|
||||
var e = math.matrix([[5, 6], [1, 1]]);
|
||||
print(e); // [[5, 6], [1, 1]]
|
||||
|
||||
// set d submatrix
|
||||
e.set([2, [1, 2]], [[7, 8]]);
|
||||
// set d submatrix.
|
||||
// Matrix indexes are zero-based.
|
||||
e.set([1, [0, 1]], [[7, 8]]);
|
||||
print(e); // [[5, 6], [7, 8]]
|
||||
var f = math.multiply(d, e);
|
||||
print(f); // [[19, 22], [43, 50]]
|
||||
var g = f.get([2, 1]);
|
||||
var g = f.get([1, 0]);
|
||||
print(g); // 43
|
||||
console.log();
|
||||
|
||||
// get d sub matrix
|
||||
// Matrix indexes are zero-based.
|
||||
console.log('get a sub matrix');
|
||||
var h = math.diag(math.range(1,3));
|
||||
print(h); // [[1, 0, 0], [0, 2, 0], [0, 0, 3]]
|
||||
print(h.get([[2, 3], [2, 3]])); // [[2, 0], [0, 3]]
|
||||
print(h.get([[1, 2], [1, 2]])); // [[2, 0], [0, 3]]
|
||||
console.log();
|
||||
|
||||
// resize d multi dimensional matrix
|
||||
@ -68,7 +70,7 @@ print(i.size()); // [2, 2, 2]
|
||||
i.resize([2, 2]);
|
||||
print(i); // [[0, 0], [0, 0]]
|
||||
print(i.size()); // [2, 2]
|
||||
i.set([3, 2], 6);
|
||||
i.set([2, 1], 6);
|
||||
print(i); // [[0, 0], [0, 0], [0, 6]]
|
||||
print(i.size()); // [3, 2]
|
||||
console.log();
|
||||
@ -85,9 +87,9 @@ console.log('use the expression parser');
|
||||
var parser = math.parser();
|
||||
print(parser.eval('d = [1, 2; 3, 4]')); // [[1, 2], [3, 4]]
|
||||
print(parser.eval('e = zeros(2, 2)')); // [[0, 0], [0, 0]]
|
||||
print(parser.eval('e(1, 1:2) = [5, 6]')); // [[5, 6], [0, 0]]
|
||||
print(parser.eval('e(2, :) = [7, 8]')); // [[5, 6], [7, 8]]
|
||||
print(parser.eval('e(0, 0:1) = [5, 6]')); // [[5, 6], [0, 0]]
|
||||
print(parser.eval('e(1, :) = [7, 8]')); // [[5, 6], [7, 8]]
|
||||
print(parser.eval('f = d * e')); // [[19, 22], [43, 50]]
|
||||
print(parser.eval('g = f(2, 1)')); // 43
|
||||
print(parser.eval('g = f(:, 1)')); // [[19], [43]]
|
||||
print(parser.eval('g = f(1, 0)')); // 43
|
||||
print(parser.eval('g = f(:, 0)')); // [[19], [43]]
|
||||
console.log();
|
||||
|
||||
@ -17,7 +17,7 @@ math.docs.range = {
|
||||
'range(0, 2, 10)',
|
||||
'range("4:10")',
|
||||
'a = [1, 2, 3; 4, 5, 6]',
|
||||
'a(:, 2:3)'
|
||||
'a(:, 1:2)'
|
||||
],
|
||||
'seealso': [
|
||||
'boolean', 'complex', 'matrix', 'number', 'string', 'unit'
|
||||
|
||||
@ -11,11 +11,11 @@ math.docs.subset = {
|
||||
'examples': [
|
||||
'd = [1, 2; 3, 4]',
|
||||
'e = []',
|
||||
'e(1, 1:2) = [5, 6]',
|
||||
'e(2, :) = [7, 8]',
|
||||
'e(0, 0:1) = [5, 6]',
|
||||
'e(1, :) = [7, 8]',
|
||||
'f = d * e',
|
||||
'f(2, 1)',
|
||||
'f(:, 1)'
|
||||
'f(1, 0)',
|
||||
'f(:, 0)'
|
||||
],
|
||||
'seealso': [
|
||||
'concat', 'det', 'diag', 'eye', 'inv', 'ones', 'range', 'size', 'squeeze', 'transpose', 'zeros'
|
||||
|
||||
@ -66,7 +66,7 @@ ParamsNode.prototype.eval = function() {
|
||||
for (i = 0, len = this.params.length; i < len; i++) {
|
||||
var paramScope = paramScopes[i];
|
||||
if (paramScope) {
|
||||
paramScope.set('end', size[i]);
|
||||
paramScope.set('end', size[i] - 1); // zero-based end
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -72,7 +72,7 @@ UpdateNode.prototype.eval = function() {
|
||||
for (var i = 0, len = this.params.length; i < len; i++) {
|
||||
var paramScope = paramScopes[i];
|
||||
if (paramScope) {
|
||||
paramScope.set('end', size[i]);
|
||||
paramScope.set('end', size[i] - 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
* math.concat(A, B, C, ...)
|
||||
* math.concat(A, B, C, ..., dim)
|
||||
*
|
||||
* Where the optional dim is the one-based number of the dimension to be
|
||||
* Where the optional dim is the zero-based number of the dimension to be
|
||||
* concatenated.
|
||||
*
|
||||
* @param {... Array | Matrix} args
|
||||
@ -13,7 +13,7 @@
|
||||
math.concat = function concat (args) {
|
||||
var i,
|
||||
len = arguments.length,
|
||||
dim = -1, // one-based dimension
|
||||
dim = -1, // zero-based dimension
|
||||
prevDim,
|
||||
asMatrix = false,
|
||||
matrices = []; // contains multi dimensional arrays
|
||||
@ -31,7 +31,7 @@ math.concat = function concat (args) {
|
||||
prevDim = dim;
|
||||
dim = arg;
|
||||
|
||||
if (!isInteger(dim) || dim < 1) {
|
||||
if (!isInteger(dim) || dim < 0) {
|
||||
throw new TypeError('Dimension number must be a positive integer ' +
|
||||
'(dim = ' + dim + ')');
|
||||
}
|
||||
@ -47,7 +47,7 @@ math.concat = function concat (args) {
|
||||
var size = math.size(arg).valueOf();
|
||||
matrices[i] = matrix;
|
||||
prevDim = dim;
|
||||
dim = size.length;
|
||||
dim = size.length - 1;
|
||||
|
||||
// verify whether each of the matrices has the same number of dimensions
|
||||
if (i > 0 && dim != prevDim) {
|
||||
@ -66,7 +66,7 @@ math.concat = function concat (args) {
|
||||
|
||||
var res = matrices.shift();
|
||||
while (matrices.length) {
|
||||
res = _concat(res, matrices.shift(), dim - 1, 0);
|
||||
res = _concat(res, matrices.shift(), dim, 0);
|
||||
}
|
||||
|
||||
return asMatrix ? new Matrix(res) : res;
|
||||
|
||||
@ -90,7 +90,7 @@ function _getSubstring(str, index) {
|
||||
for (i = 0, len = index.length; i < len; i++) {
|
||||
var index_i = index[i];
|
||||
util.validateIndex(index_i, strLen);
|
||||
substr += str.charAt(index_i - 1); // index_i is one based
|
||||
substr += str.charAt(index_i); // index_i is zero based
|
||||
}
|
||||
|
||||
return substr;
|
||||
@ -178,7 +178,7 @@ function _setSubstring(str, index, replacement) {
|
||||
for (i = 0, len = index.length; i < len; i++) {
|
||||
var index_i = index[i];
|
||||
util.validateIndex(index_i);
|
||||
chars[index_i - 1] = replacement.charAt(i); // index_i is one based
|
||||
chars[index_i] = replacement.charAt(i); // index_i is zero based
|
||||
}
|
||||
|
||||
// initialize undefined characters with a space
|
||||
|
||||
@ -534,8 +534,8 @@
|
||||
var node, name, fn, params = [];
|
||||
|
||||
if (token == ':') {
|
||||
// implicit start=1
|
||||
node = new ConstantNode(1);
|
||||
// implicit start=0
|
||||
node = new ConstantNode(0);
|
||||
}
|
||||
else {
|
||||
// explicit start
|
||||
|
||||
@ -15,7 +15,7 @@
|
||||
* matix.size(); // [2, 2]
|
||||
* matrix.resize([3, 2], 5);
|
||||
* matrix.valueOf(); // [[1, 2], [3, 4], [5, 5]]
|
||||
* matrix.get([2,1]) // 3
|
||||
* matrix.get([1,2]) // 3 (indexes are zero-based)
|
||||
*
|
||||
* @param {Array | Matrix} [data] A multi dimensional array
|
||||
*/
|
||||
@ -50,21 +50,21 @@ math.type.Matrix = Matrix;
|
||||
|
||||
/**
|
||||
* Get a value or a submatrix of the matrix.
|
||||
* @param {Array | Matrix} index One-based index
|
||||
* @param {Array | Matrix} index Zero-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);
|
||||
return (i != 0);
|
||||
});
|
||||
index = index.valueOf();
|
||||
}
|
||||
else if (index instanceof Array) {
|
||||
isScalar = !index.some(function (elem) {
|
||||
var size = math.size(elem);
|
||||
return (size.length != 0) && (size != [1]);
|
||||
return (size.length != 0) && (size != [0]);
|
||||
});
|
||||
}
|
||||
else {
|
||||
@ -100,13 +100,13 @@ Matrix.prototype.get = function (index) {
|
||||
* - index is a non-negative integer
|
||||
* - index does not exceed the dimensions of array
|
||||
* @param {Array} array
|
||||
* @param {Number} index One-based index
|
||||
* @param {Number} index Zero-based index
|
||||
* @return {*} value
|
||||
* @private
|
||||
*/
|
||||
function _get (array, index) {
|
||||
util.validateIndex(index, array.length);
|
||||
return array[index - 1]; // one-based index
|
||||
return array[index]; // zero-based index
|
||||
}
|
||||
|
||||
/**
|
||||
@ -114,7 +114,7 @@ function _get (array, index) {
|
||||
* value in the matrix.
|
||||
* Index is not checked for correct number of dimensions.
|
||||
* @param {Array} data
|
||||
* @param {Number[]} index One-based index
|
||||
* @param {Number[]} index Zero-based index
|
||||
* @return {*} scalar
|
||||
* @private
|
||||
*/
|
||||
@ -126,10 +126,10 @@ function _getScalar (data, index) {
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a submatrix of a one dimensional matrix.
|
||||
* Get a submatrix of a zero dimensional matrix.
|
||||
* Index is not checked for correct number of dimensions.
|
||||
* @param {Array} data
|
||||
* @param {Array} index One-based index
|
||||
* @param {Array} index Zero-based index
|
||||
* @return {Array} submatrix
|
||||
* @private
|
||||
*/
|
||||
@ -153,7 +153,7 @@ function _getSubmatrix1D (data, index) {
|
||||
* Get a submatrix of a 2 dimensional matrix.
|
||||
* Index is not checked for correct number of dimensions.
|
||||
* @param {Array} data
|
||||
* @param {Array} index One-based index
|
||||
* @param {Array} index Zero-based index
|
||||
* @return {Array} submatrix
|
||||
* @private
|
||||
*/
|
||||
@ -201,7 +201,7 @@ function _getSubmatrix2D (data, index) {
|
||||
* Get a submatrix of a multi dimensional matrix.
|
||||
* Index is not checked for correct number of dimensions.
|
||||
* @param {Array} data
|
||||
* @param {Array} index One-based index
|
||||
* @param {Array} index Zero-based index
|
||||
* @param {number} dim
|
||||
* @return {Array} submatrix
|
||||
* @private
|
||||
@ -228,24 +228,24 @@ function _getSubmatrix (data, index, dim) {
|
||||
|
||||
/**
|
||||
* Replace a value or a submatrix in the matrix.
|
||||
* Indexes are one-based.
|
||||
* @param {Array | Matrix} index One-based index
|
||||
* Indexes are zero-based.
|
||||
* @param {Array | Matrix} index zero-based index
|
||||
* @param {*} submatrix
|
||||
* @return {Matrix} itself
|
||||
*/
|
||||
Matrix.prototype.set = function (index, submatrix) {
|
||||
var isScalar;
|
||||
if (index instanceof Matrix) {
|
||||
// index is scalar when size==[n] or size==[1,1,...]
|
||||
// index is scalar when size==[n] or size==[0,0,...]
|
||||
isScalar = (index.size().length == 1) || !index.size().some(function (i) {
|
||||
return (i != 1);
|
||||
return (i != 0);
|
||||
});
|
||||
index = index.valueOf();
|
||||
}
|
||||
else if (index instanceof Array) {
|
||||
isScalar = !index.some(function (elem) {
|
||||
var size = math.size(elem);
|
||||
return (size.length != 0) && (size != [1]);
|
||||
return (size.length != 0) && (size != [0]);
|
||||
});
|
||||
}
|
||||
else {
|
||||
@ -291,7 +291,7 @@ Matrix.prototype.set = function (index, submatrix) {
|
||||
* Replace a single value in an array. The method tests whether index is a
|
||||
* non-negative integer
|
||||
* @param {Array} array
|
||||
* @param {Number} index One-based index
|
||||
* @param {Number} index Zero-based index
|
||||
* @param {*} value
|
||||
* @private
|
||||
*/
|
||||
@ -300,14 +300,14 @@ function _set (array, index, value) {
|
||||
if (value instanceof Array) {
|
||||
throw new TypeError('Dimension mismatch, value expected instead of array');
|
||||
}
|
||||
array[index - 1] = value; // one-based index
|
||||
array[index] = value; // zero-based index
|
||||
}
|
||||
|
||||
/**
|
||||
* Replace a single value in a multi dimensional matrix
|
||||
* @param {Array} data
|
||||
* @param {Number[]} size
|
||||
* @param {Number[]} index One-based index
|
||||
* @param {Number[]} index Zero-based index
|
||||
* @param {*} value
|
||||
* @private
|
||||
*/
|
||||
@ -321,8 +321,8 @@ function _setScalar (data, size, index, value) {
|
||||
for (var i = 0; i < index.length; i++) {
|
||||
var index_i = index[i];
|
||||
util.validateIndex(index_i);
|
||||
if ((size[i] == null) || (index_i > size[i])) {
|
||||
size[i] = index_i;
|
||||
if ((size[i] == null) || (index_i + 1 > size[i])) {
|
||||
size[i] = index_i + 1; // size is index + 1 as index is zero-based
|
||||
resized = true;
|
||||
}
|
||||
}
|
||||
@ -334,37 +334,37 @@ function _setScalar (data, size, index, value) {
|
||||
var len = size.length;
|
||||
index.forEach(function (v, i) {
|
||||
if (i < len - 1) {
|
||||
data = data[v - 1]; // one-based index
|
||||
data = data[v]; // zero-based index
|
||||
}
|
||||
else {
|
||||
data[v - 1] = value; // one-based index
|
||||
data[v] = value; // zero-based index
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Replace a single value in a one dimensional matrix
|
||||
* Replace a single value in a zero dimensional matrix
|
||||
* @param {Array} data
|
||||
* @param {Number[]} size
|
||||
* @param {Number[]} index One-based index
|
||||
* @param {Number[]} index zero-based index
|
||||
* @param {*} value
|
||||
* @private
|
||||
*/
|
||||
function _setScalar1D (data, size, index, value) {
|
||||
var row = index[0];
|
||||
util.validateIndex(row);
|
||||
if (row > size[0]) {
|
||||
util.resize(data, [row], 0);
|
||||
size[0] = row;
|
||||
if (row + 1 > size[0]) {
|
||||
util.resize(data, [row + 1], 0); // size is index + 1 as index is zero-based
|
||||
size[0] = row + 1;
|
||||
}
|
||||
data[row - 1] = value; // one-based index
|
||||
data[row] = value; // zero-based index
|
||||
}
|
||||
|
||||
/**
|
||||
* Replace a single value in a two dimensional matrix
|
||||
* @param {Array} data
|
||||
* @param {Number[]} size
|
||||
* @param {Number[]} index One-based index
|
||||
* @param {Number[]} index zero-based index
|
||||
* @param {*} value
|
||||
* @private
|
||||
*/
|
||||
@ -375,26 +375,26 @@ function _setScalar2D (data, size, index, value) {
|
||||
util.validateIndex(col);
|
||||
|
||||
var resized = false;
|
||||
if (row > (size[0] || 0)) {
|
||||
size[0] = row;
|
||||
if (row + 1 > (size[0] || 0)) {
|
||||
size[0] = row + 1; // size is index + 1 as index is zero-based
|
||||
resized = true;
|
||||
}
|
||||
if (col > (size[1] || 0)) {
|
||||
size[1] = col;
|
||||
if (col + 1 > (size[1] || 0)) {
|
||||
size[1] = col + 1; // size is index + 1 as index is zero-based
|
||||
resized = true;
|
||||
}
|
||||
if (resized) {
|
||||
util.resize(data, size, 0);
|
||||
}
|
||||
|
||||
data[row - 1][col - 1] = value; // one-based index
|
||||
data[row][col] = value; // zero-based index
|
||||
}
|
||||
|
||||
/**
|
||||
* Replace a submatrix of a multi dimensional matrix.
|
||||
* @param {Array} data
|
||||
* @param {Array} size
|
||||
* @param {Array} index One-based index
|
||||
* @param {Array} index zero-based index
|
||||
* @param {number} dim
|
||||
* @param {Array} submatrix
|
||||
* @private
|
||||
@ -405,17 +405,17 @@ function _setSubmatrix (data, size, index, dim, submatrix) {
|
||||
var recurse = function (dataIndex, subIndex) {
|
||||
if (last) {
|
||||
_set(data, dataIndex, submatrix[subIndex]);
|
||||
if (dataIndex > (size[dim] || 0)) {
|
||||
size[dim] = dataIndex;
|
||||
if (dataIndex + 1 > (size[dim] || 0)) {
|
||||
size[dim] = dataIndex + 1;
|
||||
}
|
||||
}
|
||||
else {
|
||||
var child = data[dataIndex - 1]; // one-based index
|
||||
var child = data[dataIndex]; // zero-based index
|
||||
if (!(child instanceof Array)) {
|
||||
data[dataIndex - 1] = child = [child]; // one-based index
|
||||
data[dataIndex] = child = [child]; // zero-based index
|
||||
}
|
||||
if (dataIndex > (size[dim] || 0)) {
|
||||
size[dim] = dataIndex;
|
||||
if (dataIndex + 1 > (size[dim] || 0)) {
|
||||
size[dim] = dataIndex + 1;
|
||||
}
|
||||
_setSubmatrix(child, size, index, dim + 1, submatrix[subIndex]);
|
||||
}
|
||||
@ -500,7 +500,7 @@ Matrix.prototype.map = function (callback) {
|
||||
var recurse = function (value, dim) {
|
||||
if (value instanceof Array) {
|
||||
return value.map(function (child, i) {
|
||||
index[dim] = i + 1; // one-based index
|
||||
index[dim] = i; // zero-based index
|
||||
return recurse(child, dim + 1);
|
||||
});
|
||||
}
|
||||
@ -526,7 +526,7 @@ Matrix.prototype.forEach = function (callback) {
|
||||
var recurse = function (value, dim) {
|
||||
if (value instanceof Array) {
|
||||
value.forEach(function (child, i) {
|
||||
index[dim] = i + 1; // one-based index
|
||||
index[dim] = i; // zero-based index
|
||||
recurse(child, dim + 1);
|
||||
});
|
||||
}
|
||||
|
||||
16
src/util.js
16
src/util.js
@ -620,19 +620,19 @@ var util = (function () {
|
||||
};
|
||||
|
||||
/**
|
||||
* 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
|
||||
* Test whether index is an integer number with index >= 0 and index < length
|
||||
* @param {*} index Zero-based index
|
||||
* @param {Number} [length] Length of the array
|
||||
*/
|
||||
util.validateIndex = function validateIndex (index, max) {
|
||||
util.validateIndex = function validateIndex (index, length) {
|
||||
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 (index < 0) {
|
||||
throw new RangeError('Index out of range (' + index + ' < 0)');
|
||||
}
|
||||
if (max && index > max) {
|
||||
throw new RangeError('Index out of range (' + index + ' > ' + max + ')');
|
||||
if (length !== undefined && index >= length) {
|
||||
throw new RangeError('Index out of range (' + index + ' >= ' + length + ')');
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
@ -107,36 +107,36 @@ parser.set('a', matrix([
|
||||
[4,5,6],
|
||||
[7,8,9]
|
||||
]));
|
||||
assert.deepEqual(parser.eval('a(2, :)'), matrix([[4,5,6]]));
|
||||
assert.deepEqual(parser.eval('a(2, :2)'), matrix([[4,5]]));
|
||||
assert.deepEqual(parser.eval('a(2, :end-1)'), matrix([[4,5]]));
|
||||
assert.deepEqual(parser.eval('a(2, 2:)'), matrix([[5,6]]));
|
||||
assert.deepEqual(parser.eval('a(2, 2:3)'), matrix([[5,6]]));
|
||||
assert.deepEqual(parser.eval('a(2, 1:2:3)'), matrix([[4,6]]));
|
||||
assert.deepEqual(parser.eval('a(:, 2)'), matrix([[2],[5],[8]]));
|
||||
assert.deepEqual(parser.eval('a(:2, 2)'), matrix([[2],[5]]));
|
||||
assert.deepEqual(parser.eval('a(:end-1, 2)'), matrix([[2],[5]]));
|
||||
assert.deepEqual(parser.eval('a(2:, 2)'), matrix([[5],[8]]));
|
||||
assert.deepEqual(parser.eval('a(2:3, 2)'), matrix([[5],[8]]));
|
||||
assert.deepEqual(parser.eval('a(1:2:3, 2)'), matrix([[2],[8]]));
|
||||
assert.deepEqual(parser.eval('a(1, :)'), matrix([[4,5,6]]));
|
||||
assert.deepEqual(parser.eval('a(1, :1)'), matrix([[4,5]]));
|
||||
assert.deepEqual(parser.eval('a(1, :end-1)'), matrix([[4,5]]));
|
||||
assert.deepEqual(parser.eval('a(1, 1:)'), matrix([[5,6]]));
|
||||
assert.deepEqual(parser.eval('a(1, 1:2)'), matrix([[5,6]]));
|
||||
assert.deepEqual(parser.eval('a(1, 0:2:2)'), matrix([[4,6]]));
|
||||
assert.deepEqual(parser.eval('a(:, 1)'), matrix([[2],[5],[8]]));
|
||||
assert.deepEqual(parser.eval('a(:1, 1)'), matrix([[2],[5]]));
|
||||
assert.deepEqual(parser.eval('a(:end-1, 1)'), matrix([[2],[5]]));
|
||||
assert.deepEqual(parser.eval('a(1:, 1)'), matrix([[5],[8]]));
|
||||
assert.deepEqual(parser.eval('a(1:2, 1)'), matrix([[5],[8]]));
|
||||
assert.deepEqual(parser.eval('a(0:2:2, 1)'), matrix([[2],[8]]));
|
||||
// TODO: implement and test support for Array (instead of Matrix)
|
||||
|
||||
// test matrix resizing
|
||||
assert.deepEqual(parser.eval('a = []'), matrix([[]]));
|
||||
assert.deepEqual(parser.eval('a(1:3,1) = [1;2;3]'), matrix([[1],[2],[3]]));
|
||||
assert.deepEqual(parser.eval('a(:,2) = [4;5;6]'), matrix([[1,4],[2,5],[3,6]]));
|
||||
assert.deepEqual(parser.eval('a(0:2,0) = [1;2;3]'), matrix([[1],[2],[3]]));
|
||||
assert.deepEqual(parser.eval('a(:,1) = [4;5;6]'), matrix([[1,4],[2,5],[3,6]]));
|
||||
|
||||
assert.deepEqual(parser.eval('a = []'), matrix([[]]));
|
||||
assert.deepEqual(parser.eval('a(1,3) = 3'), matrix([[0,0,3]]));
|
||||
assert.deepEqual(parser.eval('a(2,:) = [4,5,6]'), matrix([[0,0,3],[4,5,6]]));
|
||||
assert.deepEqual(parser.eval('a(0,2) = 3'), matrix([[0,0,3]]));
|
||||
assert.deepEqual(parser.eval('a(1,:) = [4,5,6]'), matrix([[0,0,3],[4,5,6]]));
|
||||
|
||||
assert.deepEqual(parser.eval('a = []'), matrix([[]]));
|
||||
assert.deepEqual(parser.eval('a(3,1) = 3'), matrix([[0],[0],[3]]));
|
||||
assert.deepEqual(parser.eval('a(:,2) = [4;5;6]'), matrix([[0,4],[0,5],[3,6]]));
|
||||
assert.deepEqual(parser.eval('a(2,0) = 3'), matrix([[0],[0],[3]]));
|
||||
assert.deepEqual(parser.eval('a(:,1) = [4;5;6]'), matrix([[0,4],[0,5],[3,6]]));
|
||||
|
||||
assert.deepEqual(parser.eval('a = []'), matrix([[]]));
|
||||
assert.deepEqual(parser.eval('a(1,1:3) = [1,2,3]'), matrix([[1,2,3]]));
|
||||
assert.deepEqual(parser.eval('a(2,:) = [4,5,6]'), matrix([[1,2,3],[4,5,6]]));
|
||||
assert.deepEqual(parser.eval('a(0,0:2) = [1,2,3]'), matrix([[1,2,3]]));
|
||||
assert.deepEqual(parser.eval('a(1,:) = [4,5,6]'), matrix([[1,2,3],[4,5,6]]));
|
||||
|
||||
// test matrix sizes
|
||||
assert.ok(parser.eval('[1,2;3,4]') instanceof math.type.Matrix);
|
||||
@ -146,28 +146,28 @@ assert.deepEqual(m.valueOf(), [[1,2,3],[4,5,6]]);
|
||||
var b = parser.eval('[5, 6; 1, 1]');
|
||||
assert.deepEqual(b.size(), [2,2]);
|
||||
assert.deepEqual(b.valueOf(), [[5,6],[1,1]]);
|
||||
b.set([2, [1, 2]], [[7, 8]]);
|
||||
b.set([1, [0, 1]], [[7, 8]]);
|
||||
assert.deepEqual(b.size(), [2,2]);
|
||||
assert.deepEqual(b.valueOf(), [[5,6],[7,8]]);
|
||||
assert.deepEqual(parser.eval('[ ]').valueOf(), [[]]);
|
||||
|
||||
// test matrix get/set submatrix
|
||||
parser.eval('a=[1,2;3,4]');
|
||||
parser.eval('a(1,1) = 100');
|
||||
parser.eval('a(0,0) = 100');
|
||||
assert.deepEqual(parser.get('a').size(), [2,2]);
|
||||
assert.deepEqual(parser.get('a').valueOf(), [[100,2],[3,4]]);
|
||||
parser.eval('a(2:3,2:3) = [10,11;12,13]');
|
||||
parser.eval('a(1:2,1:2) = [10,11;12,13]');
|
||||
assert.deepEqual(parser.get('a').size(), [3,3]);
|
||||
assert.deepEqual(parser.get('a').valueOf(), [[100,2,0],[3,10,11],[0,12,13]]);
|
||||
var a = parser.get('a');
|
||||
assert.deepEqual(a.get([math.range('1:3'), math.range('1:2')]).valueOf(), [[100,2],[3,10],[0,12]]);
|
||||
assert.deepEqual(parser.eval('a(1:3,1:2)').valueOf(), [[100,2],[3,10],[0,12]]);
|
||||
assert.deepEqual(a.get([math.range('0:2'), math.range('0:1')]).valueOf(), [[100,2],[3,10],[0,12]]);
|
||||
assert.deepEqual(parser.eval('a(0:2,0:1)').valueOf(), [[100,2],[3,10],[0,12]]);
|
||||
|
||||
// test get/set matrix for 3d matrix
|
||||
assert.deepEqual(parser.eval('f=[1,2;3,4]'), matrix([[1,2],[3,4]]));
|
||||
assert.deepEqual(parser.eval('size(f)'), matrix([2,2]));
|
||||
/* TODO: doesn't work correctly
|
||||
assert.deepEqual(parser.eval('f(:,:,2)=[5,6;7,8]'), matrix([
|
||||
assert.deepEqual(parser.eval('f(:,:,1)=[5,6;7,8]'), matrix([
|
||||
[
|
||||
[1,2],
|
||||
[3,4]
|
||||
@ -189,20 +189,20 @@ parser.set('f', matrix([
|
||||
]
|
||||
]));
|
||||
assert.deepEqual(parser.eval('size(f)'), matrix([2,2,2]));
|
||||
assert.deepEqual(parser.eval('f(:,:,1)'), matrix([[[1],[2]],[[3],[4]]])); // TODO: last dimension should be squeezed
|
||||
assert.deepEqual(parser.eval('f(:,:,2)'), matrix([[[5],[6]],[[7],[8]]])); // TODO: last dimension should be squeezed
|
||||
assert.deepEqual(parser.eval('f(:,2,:)'), matrix([[[2,6]],[[4,8]]]));
|
||||
assert.deepEqual(parser.eval('f(2,:,:)'), matrix([[[3,7],[4,8]]]));
|
||||
assert.deepEqual(parser.eval('f(:,:,0)'), matrix([[[1],[2]],[[3],[4]]])); // TODO: last dimension should be squeezed
|
||||
assert.deepEqual(parser.eval('f(:,:,1)'), matrix([[[5],[6]],[[7],[8]]])); // TODO: last dimension should be squeezed
|
||||
assert.deepEqual(parser.eval('f(:,1,:)'), matrix([[[2,6]],[[4,8]]]));
|
||||
assert.deepEqual(parser.eval('f(1,:,:)'), matrix([[[3,7],[4,8]]]));
|
||||
|
||||
parser.eval('a=diag([1,2,3,4])');
|
||||
assert.deepEqual(parser.eval('a(3:end, 3:end)'), matrix([[3,0],[0,4]]));
|
||||
assert.deepEqual(parser.eval('a(3:end, 2:end)=9*ones(2,3)'), matrix([
|
||||
assert.deepEqual(parser.eval('a(2:end, 2:end)'), matrix([[3,0],[0,4]]));
|
||||
assert.deepEqual(parser.eval('a(2:end, 1:end)=9*ones(2,3)'), matrix([
|
||||
[1,0,0,0],
|
||||
[0,2,0,0],
|
||||
[0,9,9,9],
|
||||
[0,9,9,9]
|
||||
]));
|
||||
assert.deepEqual(parser.eval('a(2:end-1, 2:end-1)'), matrix([[2,0],[9,9]]));
|
||||
assert.deepEqual(parser.eval('a(1:end-1, 1:end-1)'), matrix([[2,0],[9,9]]));
|
||||
|
||||
|
||||
// test matrix concatenation
|
||||
@ -278,7 +278,7 @@ assert.equal(n.eval(), 33);
|
||||
parser.remove('q');
|
||||
assert.throws(function () { n.eval(); });
|
||||
|
||||
n = parser.parse('qq(1,1)=33');
|
||||
n = parser.parse('qq(0,0)=33');
|
||||
assert.throws(function () { n.eval(); });
|
||||
parser.eval('qq=[1,2;3,4]');
|
||||
assert.deepEqual(n.eval(), matrix([[33,2],[3,4]]));
|
||||
|
||||
@ -3,9 +3,9 @@ var assert = require('assert');
|
||||
var math = require('../../../math.js');
|
||||
|
||||
assert.deepEqual(math.concat([1,2,3], [4]), [1,2,3,4]);
|
||||
assert.deepEqual(math.concat([[1],[2],[3]], [[4]], 1), [[1],[2],[3],[4]]);
|
||||
assert.deepEqual(math.concat([[1]], [[2]], 2), [[1,2]]);
|
||||
assert.deepEqual(math.concat([[1]], [[2]], 1), [[1],[2]]);
|
||||
assert.deepEqual(math.concat([[1],[2],[3]], [[4]], 0), [[1],[2],[3],[4]]);
|
||||
assert.deepEqual(math.concat([[1]], [[2]], 1), [[1,2]]);
|
||||
assert.deepEqual(math.concat([[1]], [[2]], 0), [[1],[2]]);
|
||||
var a = [[1,2],[3,4]];
|
||||
var b = [[5,6],[7,8]];
|
||||
var c = [[9,10],[11,12]];
|
||||
@ -15,7 +15,7 @@ assert.deepEqual(math.concat(math.matrix(a), math.matrix(b)), math.matrix([
|
||||
[1,2,5,6],
|
||||
[3,4,7,8]
|
||||
]));
|
||||
var ab1 = math.concat(a, b, 1);
|
||||
var ab1 = math.concat(a, b, 0);
|
||||
assert.deepEqual(math.size(ab1), [4,2]);
|
||||
assert.deepEqual(ab1, [
|
||||
[1,2],
|
||||
@ -29,7 +29,7 @@ assert.deepEqual(abc, [
|
||||
[1,2,5,6,9,10],
|
||||
[3,4,7,8,11,12]
|
||||
]);
|
||||
var abc1 = math.concat(a, b, c, 1);
|
||||
var abc1 = math.concat(a, b, c, 0);
|
||||
assert.deepEqual(math.size(abc1), [6,2]);
|
||||
assert.deepEqual(abc1, [
|
||||
[1,2],
|
||||
@ -55,7 +55,7 @@ assert.deepEqual(de, [
|
||||
[ [1,2,9,10], [3,4,11,12] ],
|
||||
[ [5,6,13,14], [7,8,15,16] ]
|
||||
]);
|
||||
var de1 = math.concat(d,e,1);
|
||||
var de1 = math.concat(d,e,0);
|
||||
assert.deepEqual(math.size(de1), [4,2,2]);
|
||||
assert.deepEqual(de1, [
|
||||
[ [1,2], [3,4] ],
|
||||
@ -63,7 +63,7 @@ assert.deepEqual(de1, [
|
||||
[ [9,10], [11,12] ],
|
||||
[ [13,14], [15,16] ]
|
||||
]);
|
||||
var de2 = math.concat(d,e,2);
|
||||
var de2 = math.concat(d,e,1);
|
||||
assert.deepEqual(math.size(de2), [2,4,2]);
|
||||
assert.deepEqual(de2, [
|
||||
[ [1,2], [3,4], [9,10], [11,12] ],
|
||||
|
||||
@ -6,10 +6,10 @@ var assert = require('assert'),
|
||||
assert.ok(math.select(45) instanceof math.type.Selector);
|
||||
assert.equal(math.select(3).add(4).subtract(2).done(), 5);
|
||||
assert.deepEqual(math.select(math.matrix([[1,2],[3,4]]))
|
||||
.set([1,1], 8)
|
||||
.set([0,0], 8)
|
||||
.multiply(3).done(), math.matrix([[24, 6], [9, 12]]));
|
||||
assert.deepEqual(math.select([[1,2],[3,4]])
|
||||
.set([1,1], 8)
|
||||
.set([0,0], 8)
|
||||
.multiply(3).done(), [[24, 6], [9, 12]]);
|
||||
assert.deepEqual(math.select().i.multiply(2).add(3).done(), math.complex(3, 2));
|
||||
assert.deepEqual(math.select().pi.divide(4).sin().pow(2).format().done(), 0.5);
|
||||
|
||||
@ -9,58 +9,58 @@ var assert = require('assert'),
|
||||
|
||||
// array
|
||||
var a = [[1,2], [3,4]];
|
||||
assert.deepEqual(subset(a, [[1,2], 2]), [[2],[4]]);
|
||||
assert.deepEqual(subset(a, [[1,2], [2]]), [[2],[4]]);
|
||||
assert.deepEqual(subset(a, [2, 1]), 3);
|
||||
assert.deepEqual(subset(a, [[0,1], 1]), [[2],[4]]);
|
||||
assert.deepEqual(subset(a, [[0,1], [1]]), [[2],[4]]);
|
||||
assert.deepEqual(subset(a, [1,0]), 3);
|
||||
|
||||
assert.throws(function () {subset(a, [7, 1])}, RangeError);
|
||||
assert.throws(function () {subset(a, [2])}, RangeError);
|
||||
assert.throws(function () {subset(a, [2,1,1])}, RangeError);
|
||||
assert.throws(function () {subset(a, [2.3, 1])}, TypeError);
|
||||
assert.throws(function () {subset(a, [6, 0])}, RangeError);
|
||||
assert.throws(function () {subset(a, [1])}, RangeError);
|
||||
assert.throws(function () {subset(a, [1,0,0])}, RangeError);
|
||||
assert.throws(function () {subset(a, [1.3, 0])}, TypeError);
|
||||
|
||||
// matrix
|
||||
var b = math.matrix(a);
|
||||
assert.deepEqual(subset(b, [[1,2], 2]), matrix([[2],[4]]));
|
||||
assert.deepEqual(subset(b, [range(1,2), [2]]), matrix([[2],[4]]));
|
||||
assert.deepEqual(subset(b, [matrix([1,2]), [2]]), matrix([[2],[4]]));
|
||||
assert.deepEqual(subset(b, [2, 1]), 3);
|
||||
assert.deepEqual(subset(b, matrix([2, 1])), 3);
|
||||
assert.deepEqual(subset(b, [[0,1], 1]), matrix([[2],[4]]));
|
||||
assert.deepEqual(subset(b, [range(0,1), [1]]), matrix([[2],[4]]));
|
||||
assert.deepEqual(subset(b, [matrix([0,1]), [1]]), matrix([[2],[4]]));
|
||||
assert.deepEqual(subset(b, [1, 0]), 3);
|
||||
assert.deepEqual(subset(b, matrix([1, 0])), 3);
|
||||
|
||||
assert.throws(function () {subset(b, [7, 1])}, RangeError);
|
||||
assert.throws(function () {subset(b, [2])}, RangeError);
|
||||
assert.throws(function () {subset(b, [2,1,1])}, RangeError);
|
||||
assert.throws(function () {subset(b, [2.3, 1])}, TypeError);
|
||||
assert.throws(function () {subset(b, [6, 0])}, RangeError);
|
||||
assert.throws(function () {subset(b, [1])}, RangeError);
|
||||
assert.throws(function () {subset(b, [1,0,0])}, RangeError);
|
||||
assert.throws(function () {subset(b, [1.3, 0])}, TypeError);
|
||||
|
||||
// range
|
||||
var c = math.diag(math.range(1,5));
|
||||
assert.deepEqual(subset(c, [2, range('1:5')]), matrix([[0,2,0,0,0]]));
|
||||
assert.deepEqual(subset(c, [range('2:3'), range('1:5')]), matrix([[0,2,0,0,0],[0,0,3,0,0]]));
|
||||
assert.deepEqual(subset(c, [1, range('0:4')]), matrix([[0,2,0,0,0]]));
|
||||
assert.deepEqual(subset(c, [range('1:2'), range('0:4')]), matrix([[0,2,0,0,0],[0,0,3,0,0]]));
|
||||
|
||||
assert.throws(function () {subset(c, [2, range('3:6')])}, RangeError);
|
||||
assert.throws(function () {subset(c, [2.3, 1])}, TypeError);
|
||||
assert.throws(function () {subset(c, [1, range('2:5')])}, RangeError);
|
||||
assert.throws(function () {subset(c, [1.3, 0])}, TypeError);
|
||||
|
||||
// string
|
||||
assert.deepEqual(subset('hello', [2]), 'e');
|
||||
assert.deepEqual(subset('hello', [[2]]), 'e');
|
||||
assert.deepEqual(subset('hello', [range('5:-1:1')]), 'olleh');
|
||||
assert.deepEqual(subset('hello', [[1,5]]), 'ho');
|
||||
assert.deepEqual(subset('hello', [1]), 'e');
|
||||
assert.deepEqual(subset('hello', [[1]]), 'e');
|
||||
assert.deepEqual(subset('hello', [range('4:-1:0')]), 'olleh');
|
||||
assert.deepEqual(subset('hello', [[0,4]]), 'ho');
|
||||
|
||||
assert.throws(function () {subset('hello', 2)}, RangeError);
|
||||
assert.throws(function () {subset('hello', [[7]])}, RangeError);
|
||||
assert.throws(function () {subset('hello', [[-1]])}, RangeError);
|
||||
assert.throws(function () {subset('hello', [[2.3]])}, TypeError);
|
||||
assert.throws(function () {subset('hello', 1)}, RangeError);
|
||||
assert.throws(function () {subset('hello', [[6]])}, RangeError);
|
||||
assert.throws(function () {subset('hello', [[-2]])}, RangeError);
|
||||
assert.throws(function () {subset('hello', [[1.3]])}, TypeError);
|
||||
|
||||
// scalar
|
||||
assert.deepEqual(subset(123, [1]), 123);
|
||||
assert.deepEqual(subset(math.complex('2+3i'), [1]), math.complex(2,3));
|
||||
assert.deepEqual(subset(123, [[1,1]]), [123, 123]);
|
||||
assert.deepEqual(subset(123, [0]), 123);
|
||||
assert.deepEqual(subset(math.complex('2+3i'), [0]), math.complex(2,3));
|
||||
assert.deepEqual(subset(123, [[0,0]]), [123, 123]);
|
||||
|
||||
assert.throws(function () {subset(123, [2])}, RangeError);
|
||||
assert.throws(function () {subset(123, [0])}, RangeError);
|
||||
assert.throws(function () {subset(123, [1])}, RangeError);
|
||||
assert.throws(function () {subset(123, [-1])}, RangeError);
|
||||
assert.throws(function () {subset(123, [2,3])}, RangeError);
|
||||
assert.throws(function () {subset(123, [1,1])}, RangeError); // TODO: this should be supported
|
||||
assert.throws(function () {subset(123, [3.4])}, TypeError);
|
||||
assert.throws(function () {subset(123, [-2])}, RangeError);
|
||||
assert.throws(function () {subset(123, [1,2])}, RangeError);
|
||||
assert.throws(function () {subset(123, [0,0])}, RangeError); // TODO: this should be supported
|
||||
assert.throws(function () {subset(123, [2.4])}, TypeError);
|
||||
|
||||
|
||||
|
||||
@ -68,74 +68,73 @@ assert.throws(function () {subset(123, [3.4])}, TypeError);
|
||||
|
||||
// array
|
||||
var d = [[1,2], [3,4]];
|
||||
var e = subset(d, [[1,2], 2], [[-2],[-4]]);
|
||||
var e = subset(d, [[0,1], 1], [[-2],[-4]]);
|
||||
assert.deepEqual(d, [[1,2], [3,4]]);
|
||||
assert.deepEqual(e, [[1,-2], [3,-4]]);
|
||||
var f = subset(d, [3, [1,2]], [[5,6]]);
|
||||
var f = subset(d, [2, [0,1]], [[5,6]]);
|
||||
assert.deepEqual(d, [[1,2], [3,4]]);
|
||||
assert.deepEqual(f, [[1,2], [3,4], [5,6]]);
|
||||
var f2 = subset(d, [1,1], 123);
|
||||
var f2 = subset(d, [0,0], 123);
|
||||
assert.deepEqual(d, [[1,2], [3,4]]);
|
||||
assert.deepEqual(f2, [[123,2], [3,4]]);
|
||||
|
||||
assert.throws(function () {subset(d, [2], 123)}, RangeError);
|
||||
assert.throws(function () {subset(d, [2.3,1], 123)}, TypeError);
|
||||
assert.throws(function () {subset(d, [1], 123)}, RangeError);
|
||||
assert.throws(function () {subset(d, [1.3,0], 123)}, TypeError);
|
||||
|
||||
// matrix
|
||||
var g = matrix([[1,2], [3,4]]);
|
||||
var h = subset(g, [[1,2], 2], [[-2],[-4]]);
|
||||
var h = subset(g, [[0,1], 1], [[-2],[-4]]);
|
||||
assert.deepEqual(g, matrix([[1,2], [3,4]]));
|
||||
assert.deepEqual(h, matrix([[1,-2], [3,-4]]));
|
||||
var i = subset(g, [3, [1,2]], [[5,6]]);
|
||||
var i = subset(g, [2, [0,1]], [[5,6]]);
|
||||
assert.deepEqual(g, matrix([[1,2], [3,4]]));
|
||||
assert.deepEqual(i, matrix([[1,2], [3,4], [5,6]]));
|
||||
|
||||
assert.throws(function () {subset(d, [2], 123)}, RangeError);
|
||||
assert.throws(function () {subset(d, [2.3,1], 123)}, TypeError);
|
||||
assert.throws(function () {subset(d, [1], 123)}, RangeError);
|
||||
assert.throws(function () {subset(d, [1.3,0], 123)}, TypeError);
|
||||
|
||||
// range
|
||||
assert.deepEqual(subset(range('1:5'), [range('2:4')], range('4:-1:2')), [1,4,3,2,5]);
|
||||
assert.deepEqual(subset(range('1:5'), [range('1:3')], range('4:-1:2')), [1,4,3,2,5]);
|
||||
|
||||
// string
|
||||
var j = 'hello';
|
||||
assert.deepEqual(subset(j, [[1,6]], 'H!'), 'Hello!');
|
||||
assert.deepEqual(subset(j, [[0,5]], 'H!'), 'Hello!');
|
||||
assert.deepEqual(j, 'hello');
|
||||
assert.deepEqual(subset(j, [1], 'H'), 'Hello');
|
||||
assert.deepEqual(subset(j, [0], 'H'), 'Hello');
|
||||
assert.deepEqual(j, 'hello');
|
||||
assert.deepEqual(subset(j, [range(6,11)], ' world'), 'hello world');
|
||||
assert.deepEqual(subset(j, [range(5,10)], ' world'), 'hello world');
|
||||
assert.deepEqual(j, 'hello');
|
||||
|
||||
assert.throws(function () {subset('hello', [[2,3]], '1234')}, RangeError);
|
||||
assert.throws(function () {subset('hello', [2,3], 'a')}, RangeError);
|
||||
assert.throws(function () {subset('hello', [[1,2]], '1234')}, RangeError);
|
||||
assert.throws(function () {subset('hello', [1,2], 'a')}, RangeError);
|
||||
|
||||
// scalar
|
||||
assert.deepEqual(subset(123, [1], 456), 456);
|
||||
assert.deepEqual(subset(123, [1,1], 456), 456);
|
||||
assert.deepEqual(subset(math.complex('2+3i'), [1], 123), 123);
|
||||
assert.deepEqual(subset(123, [2], 456), [123, 456]);
|
||||
assert.deepEqual(subset(123, [0], 456), 456);
|
||||
assert.deepEqual(subset(123, [0,0], 456), 456);
|
||||
assert.deepEqual(subset(math.complex('2+3i'), [0], 123), 123);
|
||||
assert.deepEqual(subset(123, [1], 456), [123, 456]);
|
||||
|
||||
assert.throws(function () {subset(123, [0], 456)}, RangeError);
|
||||
assert.throws(function () {subset(123, [-1], 456)}, RangeError);
|
||||
assert.throws(function () {subset(123, [3.4], 456)}, TypeError);
|
||||
assert.throws(function () {subset(123, [-2], 456)}, RangeError);
|
||||
assert.throws(function () {subset(123, [2.4], 456)}, TypeError);
|
||||
|
||||
|
||||
|
||||
// 3. WITH PARSER
|
||||
var parser = math.parser();
|
||||
assert.deepEqual(parser.eval('a = [1,2;3,4]'), matrix([[1,2],[3,4]]));
|
||||
assert.deepEqual(parser.eval('a(2,2)'), 4);
|
||||
assert.deepEqual(parser.eval('a(:,2)'), matrix([[2],[4]]));
|
||||
assert.deepEqual(parser.eval('a(:,2) = [-2;-4]'), matrix([[1,-2],[3,-4]]));
|
||||
assert.deepEqual(parser.eval('a(1,1)'), 4);
|
||||
assert.deepEqual(parser.eval('a(:,1)'), matrix([[2],[4]]));
|
||||
assert.deepEqual(parser.eval('a(:,1) = [-2;-4]'), matrix([[1,-2],[3,-4]]));
|
||||
assert.deepEqual(parser.eval('b=123'), 123);
|
||||
assert.deepEqual(parser.eval('b(1)'), 123);
|
||||
// assert.deepEqual(parser.eval('b(1,1)'), 123); // TODO: should be supported?
|
||||
assert.deepEqual(parser.eval('b(1)=456'), 456);
|
||||
assert.deepEqual(parser.eval('b(0)'), 123);
|
||||
// assert.deepEqual(parser.eval('b(0,0)'), 123); // TODO: should be supported?
|
||||
assert.deepEqual(parser.eval('b(0)=456'), 456);
|
||||
assert.deepEqual(parser.eval('b'), 456);
|
||||
assert.deepEqual(parser.eval('c="hello"'), "hello");
|
||||
assert.deepEqual(parser.eval('c(2:4)'), "ell");
|
||||
assert.deepEqual(parser.eval('c(2:4)'), "ell");
|
||||
assert.deepEqual(parser.eval('c(1) = "H"'), "Hello");
|
||||
assert.deepEqual(parser.eval('c(1:3)'), "ell");
|
||||
assert.deepEqual(parser.eval('c(0) = "H"'), "Hello");
|
||||
assert.deepEqual(parser.eval('c'), "Hello");
|
||||
assert.deepEqual(parser.eval('c(6:11) = " world"'), "Hello world");
|
||||
assert.deepEqual(parser.eval('c(5:-1:1)'), "olleH");
|
||||
assert.deepEqual(parser.eval('c(end:-1:1)'), "dlrow olleH");
|
||||
assert.deepEqual(parser.eval('c(5:10) = " world"'), "Hello world");
|
||||
assert.deepEqual(parser.eval('c(4:-1:0)'), "olleH");
|
||||
assert.deepEqual(parser.eval('c(end:-1:0)'), "dlrow olleH");
|
||||
|
||||
@ -8,24 +8,24 @@ assert.equal(m.isScalar(), true);
|
||||
assert.equal(m.isVector(), true);
|
||||
assert.deepEqual(m.size(), [0]);
|
||||
assert.deepEqual(m.toScalar(), null);
|
||||
assert.throws(function () { m.get([0]); });
|
||||
assert.throws(function () { m.get([-1]); });
|
||||
|
||||
m = math.matrix([[23]]);
|
||||
assert.equal(m.isScalar(), true);
|
||||
assert.equal(m.isVector(), true);
|
||||
assert.deepEqual(m.size(), [1,1]);
|
||||
assert.deepEqual(m.toScalar(), 23);
|
||||
assert.deepEqual(m.get([1,1]), 23);
|
||||
assert.deepEqual(m.get([0,0]), 23);
|
||||
|
||||
m = math.matrix([[1,2,3],[4,5,6]]);
|
||||
assert.equal(m.isScalar(), false);
|
||||
assert.equal(m.isVector(), false);
|
||||
assert.deepEqual(m.size(), [2,3]);
|
||||
assert.equal(m.get([2,3]), 6);
|
||||
assert.equal(m.get([1,2]), 2);
|
||||
assert.throws(function () { m.get([2,3,4]); });
|
||||
assert.throws(function () { m.get([4,1]); });
|
||||
assert.throws(function () { m.get([2]); });
|
||||
assert.equal(m.get([1,2]), 6);
|
||||
assert.equal(m.get([0,1]), 2);
|
||||
assert.throws(function () { m.get([1,2,3]); });
|
||||
assert.throws(function () { m.get([3,0]); });
|
||||
assert.throws(function () { m.get([1]); });
|
||||
|
||||
m = math.matrix([1,2,3]);
|
||||
assert.equal(m.isScalar(), false);
|
||||
@ -87,7 +87,7 @@ assert.deepEqual(m.valueOf(), [
|
||||
[[6,6,6],[6,6,6],[6,6,6]],
|
||||
[[6,6,6],[6,6,6],[6,6,6]]
|
||||
]);
|
||||
m.set([3,3,2], 3);
|
||||
m.set([2,2,1], 3);
|
||||
assert.deepEqual(m.valueOf(), [
|
||||
[[6,6,6],[6,6,6],[6,6,6]],
|
||||
[[6,6,6],[6,6,6],[6,6,6]],
|
||||
@ -96,47 +96,47 @@ assert.deepEqual(m.valueOf(), [
|
||||
m.resize([2,2]);
|
||||
assert.deepEqual(m.size(), [2,2]);
|
||||
assert.deepEqual(m.valueOf(), [[6,6],[6,6]]);
|
||||
m.set([2,1], 3);
|
||||
m.set([1,0], 3);
|
||||
assert.deepEqual(m.valueOf(), [[6,6],[3,6]]);
|
||||
m.resize([0]);
|
||||
assert.deepEqual(m.size(), [0]);
|
||||
assert.deepEqual(m.valueOf(), []);
|
||||
|
||||
m = math.matrix();
|
||||
m.set([2,3], 5);
|
||||
m.set([1,2], 5);
|
||||
assert.deepEqual(m.size(), [2,3]);
|
||||
assert.deepEqual(m.valueOf(), [[0,0,0],[0,0,5]]);
|
||||
|
||||
// get 1-dimensional
|
||||
m = math.matrix(math.range(1,10));
|
||||
m = math.matrix(math.range(0,9));
|
||||
assert.deepEqual(m.size(), [10]);
|
||||
assert.deepEqual(m.get([[2,5,3,4]]).valueOf(), [2,5,3,4]);
|
||||
|
||||
// get 2-dimensional
|
||||
m = math.matrix([[1,2,3],[4,5,6],[7,8,9]]);
|
||||
assert.deepEqual(m.size(), [3,3]);
|
||||
assert.deepEqual(m.get([2,2]), 5);
|
||||
assert.deepEqual(m.get([[1,2],[1,2]]).valueOf(), [[1,2],[4,5]]);
|
||||
assert.deepEqual(m.get([[2], math.range(2,3)]).valueOf(), [[5,6]]);
|
||||
assert.deepEqual(m.get([1, math.range(2,3)]).valueOf(), [[2,3]]);
|
||||
assert.deepEqual(m.get([math.range(2,3), [2]]).valueOf(), [[5],[8]]);
|
||||
assert.deepEqual(m.get([math.range(2,3), 3]).valueOf(), [[6],[9]]);
|
||||
assert.deepEqual(m.get([1,1]), 5);
|
||||
assert.deepEqual(m.get([[0,1],[0,1]]).valueOf(), [[1,2],[4,5]]);
|
||||
assert.deepEqual(m.get([[1], math.range(1,2)]).valueOf(), [[5,6]]);
|
||||
assert.deepEqual(m.get([0, math.range(1,2)]).valueOf(), [[2,3]]);
|
||||
assert.deepEqual(m.get([math.range(1,2), [1]]).valueOf(), [[5],[8]]);
|
||||
assert.deepEqual(m.get([math.range(1,2), 2]).valueOf(), [[6],[9]]);
|
||||
|
||||
// get n-dimensional
|
||||
m = math.matrix([[[1,2],[3,4]], [[5,6],[7,8]]]);
|
||||
assert.deepEqual(m.size(), [2,2,2]);
|
||||
assert.deepEqual(m.get([[1,2],[1,2],[1,2]]).valueOf(), m.valueOf());
|
||||
assert.deepEqual(m.get([1,1,1]), 1);
|
||||
assert.deepEqual(m.get([[2],[2],[2]]).valueOf(), [[[8]]]);
|
||||
assert.deepEqual(m.get([[2],[2],[1,2]]).valueOf(), [[[7,8]]]);
|
||||
assert.deepEqual(m.get([[2],[1,2],[2]]).valueOf(), [[[6],[8]]]);
|
||||
assert.deepEqual(m.get([[0,1],[0,1],[0,1]]).valueOf(), m.valueOf());
|
||||
assert.deepEqual(m.get([0,0,0]), 1);
|
||||
assert.deepEqual(m.get([[1],[1],[1]]).valueOf(), [[[8]]]);
|
||||
assert.deepEqual(m.get([[1],[1],[0,1]]).valueOf(), [[[7,8]]]);
|
||||
assert.deepEqual(m.get([[1],[0,1],[1]]).valueOf(), [[[6],[8]]]);
|
||||
|
||||
// set 1-dimensional
|
||||
m = math.matrix(math.range(0,6));
|
||||
m.set([[3,4]], [20,30]);
|
||||
m.set([[2,3]], [20,30]);
|
||||
assert.deepEqual(m.size(), [7]);
|
||||
assert.deepEqual(m.valueOf(), [0,1,20,30,4,5,6]);
|
||||
m.set([5], 40);
|
||||
m.set([4], 40);
|
||||
assert.deepEqual(m.size(), [7]);
|
||||
assert.deepEqual(m.valueOf(), [0,1,20,30,40,5,6]);
|
||||
|
||||
@ -145,30 +145,30 @@ m = math.matrix();
|
||||
m.resize([3,3]);
|
||||
assert.deepEqual(m.size(), [3,3]);
|
||||
assert.deepEqual(m.valueOf(), [[0,0,0],[0,0,0],[0,0,0]]);
|
||||
m.set([[2,3], [2,3]], [[1,2],[3,4]]);
|
||||
m.set([[1,2], [1,2]], [[1,2],[3,4]]);
|
||||
assert.deepEqual(m.size(), [3,3]);
|
||||
assert.deepEqual(m.valueOf(), [[0,0,0],[0,1,2],[0,3,4]]);
|
||||
|
||||
// set 2-dimensional with resize
|
||||
m = math.matrix([[123]]);
|
||||
assert.deepEqual(m.size(), [1,1]);
|
||||
m.set([[2,3], [2,3]], [[1,2],[3,4]]);
|
||||
m.set([[1,2], [1,2]], [[1,2],[3,4]]);
|
||||
assert.deepEqual(m.size(), [3,3]);
|
||||
assert.deepEqual(m.valueOf(), [[123,0,0],[0,1,2],[0,3,4]]);
|
||||
|
||||
// set resize dimensions
|
||||
m = math.matrix([123]);
|
||||
assert.deepEqual(m.size(), [1]);
|
||||
m.set([[2,3], [2,3]], [[1,2],[3,4]]);
|
||||
m.set([[1,2], [1,2]], [[1,2],[3,4]]);
|
||||
assert.deepEqual(m.size(), [3,3]);
|
||||
assert.deepEqual(m.valueOf(), [[123,0,0],[0,1,2],[0,3,4]]);
|
||||
m.set([math.range(1,2), math.range(1,2)], [[55,55],[55,55]]);
|
||||
m.set([math.range(0,1), math.range(0,1)], [[55,55],[55,55]]);
|
||||
assert.deepEqual(m.size(), [3,3]);
|
||||
assert.deepEqual(m.valueOf(), [[55,55,0],[55,55,2],[0,3,4]]);
|
||||
|
||||
m = math.matrix();
|
||||
assert.deepEqual(m.size(), [0]);
|
||||
m.set([[2,3], [2,3], [2,3]], [[[1,2],[3,4]],[[5,6],[7,8]]]);
|
||||
m.set([[1,2], [1,2], [1,2]], [[[1,2],[3,4]],[[5,6],[7,8]]]);
|
||||
assert.deepEqual(m.size(), [3,3,3]);
|
||||
assert.deepEqual(m.valueOf(), [
|
||||
[
|
||||
@ -203,25 +203,25 @@ m.forEach(function (value, index, obj) {
|
||||
output.push(math.clone([value, index, obj === m]));
|
||||
});
|
||||
assert.deepEqual(output, [
|
||||
[1, [1, 1], true ],
|
||||
[2, [1, 2], true ],
|
||||
[3, [1, 3], true ],
|
||||
[4, [2, 1], true ],
|
||||
[5, [2, 2], true ],
|
||||
[6, [2, 3], true ]
|
||||
[1, [0, 0], true ],
|
||||
[2, [0, 1], true ],
|
||||
[3, [0, 2], true ],
|
||||
[4, [1, 0], true ],
|
||||
[5, [1, 1], true ],
|
||||
[6, [1, 2], true ]
|
||||
]);
|
||||
assert.deepEqual(m.map(function (value, index, obj) {
|
||||
return math.clone([value, index, obj === m]);
|
||||
}).valueOf(), [
|
||||
[
|
||||
[1, [1, 1], true ],
|
||||
[2, [1, 2], true ],
|
||||
[3, [1, 3], true ]
|
||||
[1, [0, 0], true ],
|
||||
[2, [0, 1], true ],
|
||||
[3, [0, 2], true ]
|
||||
],
|
||||
[
|
||||
[4, [2, 1], true ],
|
||||
[5, [2, 2], true ],
|
||||
[6, [2, 3], true ]
|
||||
[4, [1, 0], true ],
|
||||
[5, [1, 1], true ],
|
||||
[6, [1, 2], true ]
|
||||
]
|
||||
]);
|
||||
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user