archive-gh-me/mathjs
1
0
Fork 0
mirror of https://github.com/josdejong/mathjs.git synced 2026-01-18 14:59:29 +00:00
Code Issues Projects Releases Wiki Activity

Dropped string support for bitwise operators

Browse Source
This commit is contained in:
jos 2014-12-25 15:07:30 +01:00
parent eccf5d63e5
commit fe694bfd12
22 changed files with 104 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
lib/function/bitwise/bitAnd.js
View File

@ -11,7 +11,6 @@ module.exports = function (math, config) {
isBoolean = util['boolean'].isBoolean,
isInteger = util.number.isInteger,
isNumber = util.number.isNumber,
isString = util.string.isString,
isCollection = collection.isCollection,
bigBitAnd = util.bignumber.and;
@ -34,8 +33,8 @@ module.exports = function (math, config) {
*
* bitNot, bitOr, bitXor, leftShift, rightArithShift, rightLogShift
*
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} x First value to and
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} y Second value to and
* @param {Number | BigNumber | Boolean | Array | Matrix | null} x First value to and
* @param {Number | BigNumber | Boolean | Array | Matrix | null} y Second value to and
* @return {Number | BigNumber | Array | Matrix} AND of `x` and `y`
*/
math.bitAnd = function bitAnd(x, y) {
@ -55,17 +54,6 @@ module.exports = function (math, config) {
return collection.deepMap2(x, y, bitAnd);
}
if (isString(x)) {
return bitAnd((config.number === 'bignumber')
? BigNumber.convert(x)
: +x, y);
}
if (isString(y)) {
return bitAnd(x, (config.number === 'bignumber')
? BigNumber.convert(y)
: +y);
}
if (isBoolean(x) || x === null) {
return bitAnd(+x, y);
}

9
lib/function/bitwise/bitNot.js
View File

@ -11,7 +11,6 @@ module.exports = function (math, config) {
isBoolean = util['boolean'].isBoolean,
isInteger = util.number.isInteger,
isNumber = util.number.isNumber,
isString = util.string.isString,
isCollection = collection.isCollection,
bigBitNot = util.bignumber.not;
@ -35,7 +34,7 @@ module.exports = function (math, config) {
*
* bitAnd, bitOr, bitXor, leftShift, rightArithShift, rightLogShift
*
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} x Value to not
* @param {Number | BigNumber | Boolean | Array | Matrix | null} x Value to not
* @return {Number | BigNumber | Array | Matrix} NOT of `x`
*/
math.bitNot = function bitNot(x) {
@ -59,12 +58,6 @@ module.exports = function (math, config) {
return collection.deepMap(x, bitNot);
}
if (isString(x)) {
return bitNot((config.number === 'bignumber')
? BigNumber.convert(x)
: +x);
}
if (isBoolean(x) || x === null) {
return bitNot(+x);
}

16
lib/function/bitwise/bitOr.js
View File

@ -11,7 +11,6 @@ module.exports = function (math, config) {
isBoolean = util['boolean'].isBoolean,
isInteger = util.number.isInteger,
isNumber = util.number.isNumber,
isString = util.string.isString,
isCollection = collection.isCollection,
bigBitOr = util.bignumber.or;
@ -35,8 +34,8 @@ module.exports = function (math, config) {
*
* bitAnd, bitNot, bitXor, leftShift, rightArithShift, rightLogShift
*
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} x First value to or
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} y Second value to or
* @param {Number | BigNumber | Boolean | Array | Matrix | null} x First value to or
* @param {Number | BigNumber | Boolean | Array | Matrix | null} y Second value to or
* @return {Number | BigNumber | Array | Matrix} OR of `x` and `y`
*/
math.bitOr = function bitOr(x, y) {
@ -56,17 +55,6 @@ module.exports = function (math, config) {
return collection.deepMap2(x, y, bitOr);
}
if (isString(x)) {
return bitOr((config.number === 'bignumber')
? BigNumber.convert(x)
: +x, y);
}
if (isString(y)) {
return bitOr(x, (config.number === 'bignumber')
? BigNumber.convert(y)
: +y);
}
if (isBoolean(x) || x === null) {
return bitOr(+x, y);
}

17
lib/function/bitwise/bitXor.js
View File

@ -11,8 +11,6 @@ module.exports = function (math, config) {
isBoolean = util['boolean'].isBoolean,
isInteger = util.number.isInteger,
isNumber = util.number.isNumber,
isString = util.string.isString,
isUnit = Unit.isUnit,
isCollection = collection.isCollection,
bigBitXor = util.bignumber.xor;
@ -35,8 +33,8 @@ module.exports = function (math, config) {
*
* bitAnd, bitNot, bitOr, leftShift, rightArithShift, rightLogShift
*
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} x First value to xor
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} y Second value to xor
* @param {Number | BigNumber | Boolean | Array | Matrix | null} x First value to xor
* @param {Number | BigNumber | Boolean | Array | Matrix | null} y Second value to xor
* @return {Number | BigNumber | Array | Matrix} XOR of `x` and `y`
*/
math.bitXor = function bitXor(x, y) {
@ -56,17 +54,6 @@ module.exports = function (math, config) {
return collection.deepMap2(x, y, bitXor);
}
if (isString(x)) {
return bitXor((config.number === 'bignumber')
? BigNumber.convert(x)
: +x, y);
}
if (isString(y)) {
return bitXor(x, (config.number === 'bignumber')
? BigNumber.convert(y)
: +y);
}
if (isBoolean(x) || x === null) {
return bitXor(+x, y);
}

16
lib/function/bitwise/leftShift.js
View File

@ -11,7 +11,6 @@ module.exports = function (math, config) {
isBoolean = util['boolean'].isBoolean,
isInteger = util.number.isInteger,
isNumber = util.number.isNumber,
isString = util.string.isString,
isCollection = collection.isCollection,
bigLeftShift = util.bignumber.leftShift;
@ -35,8 +34,8 @@ module.exports = function (math, config) {
*
* bitAnd, bitNot, bitOr, bitXor, rightArithShift, rightLogShift
*
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} x Value to be shifted
* @param {Number | BigNumber | Boolean | String | null} y Amount of shifts
* @param {Number | BigNumber | Boolean | Array | Matrix | null} x Value to be shifted
* @param {Number | BigNumber | Boolean | null} y Amount of shifts
* @return {Number | BigNumber | Array | Matrix} `x` shifted left `y` times
*/
math.leftShift = function leftShift(x, y) {
@ -92,17 +91,6 @@ module.exports = function (math, config) {
return collection.deepMap2(x, y, leftShift);
}
if (isString(x)) {
return leftShift((config.number === 'bignumber')
? BigNumber.convert(x)
: +x, y);
}
if (isString(y)) {
return leftShift(x, (config.number === 'bignumber')
? BigNumber.convert(y)
: +y);
}
if (isBoolean(x) || x === null) {
return leftShift(+x, y);
}

16
lib/function/bitwise/rightArithShift.js
View File

@ -11,7 +11,6 @@ module.exports = function (math, config) {
isBoolean = util['boolean'].isBoolean,
isInteger = util.number.isInteger,
isNumber = util.number.isNumber,
isString = util.string.isString,
isCollection = collection.isCollection,
bigRightShift = util.bignumber.rightShift;
@ -35,8 +34,8 @@ module.exports = function (math, config) {
*
* bitAnd, bitNot, bitOr, bitXor, leftShift, rightLogShift
*
* @param {Number | BigNumber | Boolean | String | Array | Matrix | null} x Value to be shifted
* @param {Number | BigNumber | Boolean | String | null} y Amount of shifts
* @param {Number | BigNumber | Boolean | Array | Matrix | null} x Value to be shifted
* @param {Number | BigNumber | Boolean | null} y Amount of shifts
* @return {Number | BigNumber | Array | Matrix} `x` sign-filled shifted right `y` times
*/
math.rightArithShift = function rightArithShift(x, y) {
@ -94,17 +93,6 @@ module.exports = function (math, config) {
return collection.deepMap2(x, y, rightArithShift);
}
if (isString(x)) {
return rightArithShift((config.number === 'bignumber')
? BigNumber.convert(x)
: +x, y);
}
if (isString(y)) {
return rightArithShift(x, (config.number === 'bignumber')
? BigNumber.convert(y)
: +y);
}
if (isBoolean(x) || x === null) {
return rightArithShift(+x, y);
}

16
lib/function/bitwise/rightLogShift.js
View File

@ -10,7 +10,6 @@ module.exports = function (math, config) {
isBoolean = util['boolean'].isBoolean,
isInteger = util.number.isInteger,
isNumber = util.number.isNumber,
isString = util.string.isString,
isCollection = collection.isCollection;
/**
@ -32,8 +31,8 @@ module.exports = function (math, config) {
*
* bitAnd, bitNot, bitOr, bitXor, leftShift, rightArithShift
*
* @param {Number | Boolean | String | Array | Matrix | null} x Value to be shifted
* @param {Number | Boolean | String | null} y Amount of shifts
* @param {Number | Boolean | Array | Matrix | null} x Value to be shifted
* @param {Number | Boolean | null} y Amount of shifts
* @return {Number | Array | Matrix} `x` zero-filled shifted right `y` times
*/
math.rightLogShift = function rightLogShift(x, y) {
@ -53,17 +52,6 @@ module.exports = function (math, config) {
return collection.deepMap2(x, y, rightLogShift);
}
if (isString(x)) {
return rightLogShift((config.number === 'bignumber')
? BigNumber.convert(x)
: +x, y);
}
if (isString(y)) {
return rightLogShift(x, (config.number === 'bignumber')
? BigNumber.convert(y)
: +y);
}
if (isBoolean(x) || x === null) {
return rightLogShift(+x, y);
}

2
lib/function/logical/and.js
View File

@ -39,7 +39,7 @@ module.exports = function (math) {
*
* @param {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} x First value to check
* @param {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} y Second value to check
* @return {Boolean | Matrix}
* @return {Boolean | Array | Matrix}
* Returns true when both inputs are defined with a nonzero/nonempty value.
*/
math.and = function and(x, y) {

2
lib/function/logical/not.js
View File

@ -36,7 +36,7 @@ module.exports = function (math) {
* and, or, xor
*
* @param {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} x First value to check
* @return {Boolean | Matrix}
* @return {Boolean | Array | Matrix}
* Returns true when input is a zero or empty value.
*/
math.not = function not(x) {

2
lib/function/logical/or.js
View File

@ -39,7 +39,7 @@ module.exports = function (math) {
*
* @param {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} x First value to check
* @param {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} y Second value to check
* @return {Boolean | Matrix}
* @return {Boolean | Array | Matrix}
* Returns true when one of the inputs is defined with a nonzero/nonempty value.
*/
math.or = function or(x, y) {

2
lib/function/logical/xor.js
View File

@ -39,7 +39,7 @@ module.exports = function (math) {
*
* @param {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} x First value to check
* @param {Number | BigNumber | Boolean | Complex | Unit | Array | Matrix | null} y Second value to check
* @return {Boolean | Matrix}
* @return {Boolean | Array | Matrix}
* Returns true when one and only one input is defined with a nonzero/nonempty value.
*/
math.xor = function xor(x, y) {

36
test/function/bitwise/bitAnd.test.js
View File

@ -58,25 +58,12 @@ describe('bitAnd', function () {
assert.deepEqual(bitAnd(true, bignumber(3)), bignumber(1));
});
it('should bitwise and mixed strings and bignumbers', function () {
assert.deepEqual(bitAnd(bignumber('-1.0e+31'), '-1.0e+32'), bignumber('-101273397985285317082036849082368'));
assert.deepEqual(bitAnd('1.0e+32', bignumber('1.0e+31')), bignumber('8726602014714682917961003433984'));
});
it('should throw an error if used with a unit', function() {
assert.throws(function () {bitAnd(math.unit('5cm'), 2)}, error.UnsupportedTypeError);
assert.throws(function () {bitAnd(2, math.unit('5cm'))}, error.UnsupportedTypeError);
assert.throws(function () {bitAnd(math.unit('2cm'), math.unit('5cm'))}, error.UnsupportedTypeError);
});
it('should bitwise and two ints, even in string format', function () {
assert.equal(bitAnd('120', '86'), 80);
assert.equal(bitAnd('86', 120), 80);
assert.equal(bitAnd('-120', '-86'), -120);
assert.equal(bitAnd(-120, '-86'), -120);
assert.equal(bitAnd(-120, '-86e2'), -8696);
});
it('should throw an error if the parameters are not integers', function () {
assert.throws(function () {
bitAnd(1.1, 1);
@ -87,12 +74,6 @@ describe('bitAnd', function () {
assert.throws(function () {
bitAnd(1.1, 1.1);
}, /Parameters in function bitAnd must be integer numbers/);
assert.throws(function () {
bitAnd('1.1', 1);
}, /Parameters in function bitAnd must be integer numbers/);
assert.throws(function () {
bitAnd(1, '1.1');
}, /Parameters in function bitAnd must be integer numbers/);
assert.throws(function () {
bitAnd(bignumber(1.1), 1);
}, /Parameters in function bitAnd must be integer numbers/);
@ -107,14 +88,6 @@ describe('bitAnd', function () {
}, /Parameters in function bitAnd must be integer numbers/);
});
it('should bitwise and strings and matrices element wise', function () {
assert.deepEqual(bitAnd('42', ['1', 12, '31']), [0, 8, 10]);
assert.deepEqual(bitAnd(['1', 12, '31'], '42'), [0, 8, 10]);
assert.deepEqual(bitAnd('42', math.matrix(['1', 12, '31'])), math.matrix([0, 8, 10]));
assert.deepEqual(bitAnd(math.matrix(['1', 12, '31']), '42'), math.matrix([0, 8, 10]));
});
it('should bitwise and matrices correctly', function () {
var a2 = math.matrix([[1,2],[3,4]]);
var a3 = math.matrix([[5,6],[7,8]]);
@ -152,4 +125,13 @@ describe('bitAnd', function () {
assert.throws(function () {bitAnd(1, 2, 3)}, error.ArgumentsError);
});
it('should throw an error in case of invalid type of arguments', function () {
assert.throws(function () {bitAnd(new Date(), true)}, error.UnsupportedTypeError);
assert.throws(function () {bitAnd(true, new Date())}, error.UnsupportedTypeError);
assert.throws(function () {bitAnd(true, 'foo')}, error.UnsupportedTypeError);
assert.throws(function () {bitAnd('foo', true)}, error.UnsupportedTypeError);
assert.throws(function () {bitAnd(true, undefined)}, error.UnsupportedTypeError);
assert.throws(function () {bitAnd(undefined, true)}, error.UnsupportedTypeError);
});
});

11
test/function/bitwise/bitNot.test.js
View File

@ -15,12 +15,6 @@ describe('bitNot', function () {
assert.equal(bitNot(null), -1);
});
it('should return bitwise not of a string', function () {
assert.equal(bitNot('2'), -3);
assert.equal(bitNot('-2'), 1);
assert.equal(bitNot('-86e2'), 8599);
});
it('should perform bitwise not of a number', function () {
assert.deepEqual(bitNot(2), -3);
assert.deepEqual(bitNot(-2), 1);
@ -37,9 +31,6 @@ describe('bitNot', function () {
assert.throws(function () {
bitNot(1.1);
}, /Parameter in function bitNot must be integer numbers/);
assert.throws(function () {
bitNot('1.1');
}, /Parameter in function bitNot must be integer numbers/);
assert.throws(function () {
bitNot(bignumber(1.1));
}, /Parameter in function bitNot must be integer numbers/);
@ -68,6 +59,8 @@ describe('bitNot', function () {
it('should throw an error in case of invalid type of argument', function () {
assert.throws(function () {bitNot(new Date())}, error.UnsupportedTypeError);
assert.throws(function () {bitNot('foo')}, error.UnsupportedTypeError);
assert.throws(function () {bitNot(undefined)}, error.UnsupportedTypeError);
});
});

35
test/function/bitwise/bitOr.test.js
View File

@ -57,25 +57,12 @@ describe('bitOr', function () {
assert.deepEqual(bitOr(true, bignumber(2)), bignumber(3));
});
it('should bitwise or mixed strings and bignumbers', function () {
assert.deepEqual(bitOr('-1.0e+31', bignumber('-1.0e+32')), bignumber('-8726602014714682917963150917632'));
assert.deepEqual(bitOr(bignumber('1.0e+31'), '1.0e+32'), bignumber('101273397985285317082038996566016'));
});
it('should throw an error if used with a unit', function() {
assert.throws(function () {bitOr(math.unit('5cm'), 2)}, error.UnsupportedTypeError);
assert.throws(function () {bitOr(2, math.unit('5cm'))}, error.UnsupportedTypeError);
assert.throws(function () {bitOr(math.unit('2cm'), math.unit('5cm'))}, error.UnsupportedTypeError);
});
it('should bitwise or two ints, even in string format', function () {
assert.equal(bitOr('120', '86'), 126);
assert.equal(bitOr('86', 120), 126);
assert.equal(bitOr('-120', '-86'), -86);
assert.equal(bitOr(-120, '-86'), -86);
assert.equal(bitOr(-120, '-86e2'), -24);
});
it('should throw an error if the parameters are not integers', function () {
assert.throws(function () {
bitOr(1.1, 1);
@ -86,12 +73,6 @@ describe('bitOr', function () {
assert.throws(function () {
bitOr(1.1, 1.1);
}, /Parameters in function bitOr must be integer numbers/);
assert.throws(function () {
bitOr('1.1', 1);
}, /Parameters in function bitOr must be integer numbers/);
assert.throws(function () {
bitOr(1, '1.1');
}, /Parameters in function bitOr must be integer numbers/);
assert.throws(function () {
bitOr(bignumber(1.1), 1);
}, /Parameters in function bitOr must be integer numbers/);
@ -106,14 +87,6 @@ describe('bitOr', function () {
}, /Parameters in function bitOr must be integer numbers/);
});
it('should bitwise or strings and matrices element wise', function () {
assert.deepEqual(bitOr('42', ['1', 12, '31']), [43, 46, 63]);
assert.deepEqual(bitOr(['1', 12, '31'], '42'), [43, 46, 63]);
assert.deepEqual(bitOr('42', math.matrix(['1', 12, '31'])), math.matrix([43, 46, 63]));
assert.deepEqual(bitOr(math.matrix(['1', 12, '31']), '42'), math.matrix([43, 46, 63]));
});
it('should bitwise or matrices correctly', function () {
var a2 = math.matrix([[1,2],[3,4]]);
var a3 = math.matrix([[5,6],[7,8]]);
@ -150,5 +123,13 @@ describe('bitOr', function () {
assert.throws(function () {bitOr(1)}, error.ArgumentsError);
assert.throws(function () {bitOr(1, 2, 3)}, error.ArgumentsError);
});
it('should throw an error in case of invalid type of arguments', function () {
assert.throws(function () {bitOr(new Date(), true)}, error.UnsupportedTypeError);
assert.throws(function () {bitOr(true, new Date())}, error.UnsupportedTypeError);
assert.throws(function () {bitOr(true, 'foo')}, error.UnsupportedTypeError);
assert.throws(function () {bitOr('foo', true)}, error.UnsupportedTypeError);
assert.throws(function () {bitOr(true, undefined)}, error.UnsupportedTypeError);
assert.throws(function () {bitOr(undefined, true)}, error.UnsupportedTypeError);
});
});

35
test/function/bitwise/bitXor.test.js
View File

@ -59,25 +59,12 @@ describe('bitXor', function () {
assert.deepEqual(bitXor(false, bignumber(3)), bignumber(3));
});
it('should bitwise and mixed strings and bignumbers', function () {
assert.deepEqual(bitXor(bignumber('-1.0e+31'), '-1.0e+32'), bignumber('92546795970570634164073698164736'));
assert.deepEqual(bitXor('1.0e+31', bignumber('1.0e+32')), bignumber('92546795970570634164077993132032'));
});
it('should throw an error if used with a unit', function() {
assert.throws(function () {bitXor(math.unit('5cm'), 2)}, error.UnsupportedTypeError);
assert.throws(function () {bitXor(2, math.unit('5cm'))}, error.UnsupportedTypeError);
assert.throws(function () {bitXor(math.unit('2cm'), math.unit('5cm'))}, error.UnsupportedTypeError);
});
it('should xor two ints, even in string format', function () {
assert.equal(bitXor('120', '86'), 46);
assert.equal(bitXor('86', 120), 46);
assert.equal(bitXor('-120', '-86'), 34);
assert.equal(bitXor(-120, '-86'), 34);
assert.equal(bitXor(-120, '-86e2'), 8672);
});
it('should throw an error if the parameters are not integers', function () {
assert.throws(function () {
bitXor(1.1, 1);
@ -88,12 +75,6 @@ describe('bitXor', function () {
assert.throws(function () {
bitXor(1.1, 1.1);
}, /Parameters in function bitXor must be integer numbers/);
assert.throws(function () {
bitXor('1.1', 1);
}, /Parameters in function bitXor must be integer numbers/);
assert.throws(function () {
bitXor(1, '1.1');
}, /Parameters in function bitXor must be integer numbers/);
assert.throws(function () {
bitXor(bignumber(1.1), 1);
}, /Parameters in function bitXor must be integer numbers/);
@ -108,14 +89,6 @@ describe('bitXor', function () {
}, /Parameters in function bitXor must be integer numbers/);
});
it('should xor strings and matrices element wise', function () {
assert.deepEqual(bitXor('42', ['1', 12, '31']), [43, 38, 53]);
assert.deepEqual(bitXor(['1', 12, '31'], '42'), [43, 38, 53]);
assert.deepEqual(bitXor('42', math.matrix(['1', 12, '31'])), math.matrix([43, 38, 53]));
assert.deepEqual(bitXor(math.matrix(['1', 12, '31']), '42'), math.matrix([43, 38, 53]));
});
it('should xor matrices correctly', function () {
var a2 = math.matrix([[1,2],[3,4]]);
var a3 = math.matrix([[5,6],[7,8]]);
@ -152,5 +125,13 @@ describe('bitXor', function () {
assert.throws(function () {bitXor(1)}, error.ArgumentsError);
assert.throws(function () {bitXor(1, 2, 3)}, error.ArgumentsError);
});
it('should throw an error in case of invalid type of arguments', function () {
assert.throws(function () {bitXor(new Date(), true)}, error.UnsupportedTypeError);
assert.throws(function () {bitXor(true, new Date())}, error.UnsupportedTypeError);
assert.throws(function () {bitXor(true, 'foo')}, error.UnsupportedTypeError);
assert.throws(function () {bitXor('foo', true)}, error.UnsupportedTypeError);
assert.throws(function () {bitXor(true, undefined)}, error.UnsupportedTypeError);
assert.throws(function () {bitXor(undefined, true)}, error.UnsupportedTypeError);
});
});

30
test/function/bitwise/leftShift.test.js
View File

@ -64,27 +64,12 @@ describe('leftShift', function () {
assert.deepEqual(leftShift(bignumber(3), true), bignumber(6));
});
it('should left shift mixed bignumbers and string', function () {
assert.deepEqual(leftShift(bignumber(2), '3'), bignumber(16));
assert.deepEqual(leftShift('2', bignumber(3)), bignumber(16));
assert.deepEqual(leftShift(bignumber(-1), '2'), bignumber(-4));
assert.deepEqual(leftShift('-2', bignumber(3)), bignumber(-16));
});
it('should throw an error if used with a unit', function() {
assert.throws(function () {leftShift(math.unit('5cm'), 2)}, error.UnsupportedTypeError);
assert.throws(function () {leftShift(2, math.unit('5cm'))}, error.UnsupportedTypeError);
assert.throws(function () {leftShift(math.unit('2cm'), math.unit('5cm'))}, error.UnsupportedTypeError);
});
it('should left shift by values given by strings', function () {
assert.equal(leftShift('0', '1000'), 0);
assert.equal(leftShift('2', 0), 2);
assert.equal(leftShift(2, '3'), 16);
assert.equal(leftShift('-2', 2), -8);
assert.equal(leftShift(-2, '1e2'), -32);
});
it('should throw an error if the parameters are not integers', function () {
assert.throws(function () {
leftShift(1.1, 1);
@ -95,12 +80,6 @@ describe('leftShift', function () {
assert.throws(function () {
leftShift(1.1, 1.1);
}, /Parameters in function leftShift must be integer numbers/);
assert.throws(function () {
leftShift('1.1', 1);
}, /Parameters in function leftShift must be integer numbers/);
assert.throws(function () {
leftShift(1, '1.1');
}, /Parameters in function leftShift must be integer numbers/);
assert.throws(function () {
leftShift(bignumber(1.1), 1);
}, /Parameters in function leftShift must be integer numbers/);
@ -140,4 +119,13 @@ describe('leftShift', function () {
assert.throws(function () {leftShift(1, 2, 3)}, error.ArgumentsError);
});
it('should throw an error in case of invalid type of arguments', function () {
assert.throws(function () {leftShift(new Date(), true)}, error.UnsupportedTypeError);
assert.throws(function () {leftShift(true, new Date())}, error.UnsupportedTypeError);
assert.throws(function () {leftShift(true, 'foo')}, error.UnsupportedTypeError);
assert.throws(function () {leftShift('foo', true)}, error.UnsupportedTypeError);
assert.throws(function () {leftShift(true, undefined)}, error.UnsupportedTypeError);
assert.throws(function () {leftShift(undefined, true)}, error.UnsupportedTypeError);
});
});

30
test/function/bitwise/rightArithShift.test.js
View File

@ -39,14 +39,6 @@ describe('rightArithShift', function () {
assert.equal(rightArithShift(null, 1), 0);
});
it('should right arithmetically shift by values given by strings', function () {
assert.equal(rightArithShift('0', '1000'), 0);
assert.equal(rightArithShift('2', 0), 2);
assert.equal(rightArithShift(22, '3'), 2);
assert.equal(rightArithShift('-256', 2), -64);
assert.equal(rightArithShift('-256', '1e2'), -16);
});
it('should right arithmetically shift bignumbers', function () {
assert.deepEqual(rightArithShift(bignumber(17), bignumber(3)), bignumber(2));
assert.deepEqual(rightArithShift(bignumber('633825300114114700748351602688000'), bignumber(100)), bignumber(500));
@ -75,13 +67,6 @@ describe('rightArithShift', function () {
assert.deepEqual(rightArithShift(bignumber(3), true), bignumber(1));
});
it('should right arithmetically shift mixed bignumbers and string', function () {
assert.deepEqual(rightArithShift(bignumber(17), '3'), bignumber(2));
assert.deepEqual(rightArithShift('17', bignumber(3)), bignumber(2));
assert.deepEqual(rightArithShift(bignumber('-17'), '3'), bignumber(-3));
assert.deepEqual(rightArithShift('-17', bignumber(3)), bignumber(-3));
});
it('should throw an error if the parameters are not integers', function () {
assert.throws(function () {
rightArithShift(1.1, 1);
@ -92,12 +77,6 @@ describe('rightArithShift', function () {
assert.throws(function () {
rightArithShift(1.1, 1.1);
}, /Parameters in function rightArithShift must be integer numbers/);
assert.throws(function () {
rightArithShift('1.1', 1);
}, /Parameters in function rightArithShift must be integer numbers/);
assert.throws(function () {
rightArithShift(1, '1.1');
}, /Parameters in function rightArithShift must be integer numbers/);
assert.throws(function () {
rightArithShift(bignumber(1.1), 1);
}, /Parameters in function rightArithShift must be integer numbers/);
@ -143,4 +122,13 @@ describe('rightArithShift', function () {
assert.throws(function () {rightArithShift(1, 2, 3)}, error.ArgumentsError);
});
it('should throw an error in case of invalid type of arguments', function () {
assert.throws(function () {rightArithShift(new Date(), true)}, error.UnsupportedTypeError);
assert.throws(function () {rightArithShift(true, new Date())}, error.UnsupportedTypeError);
assert.throws(function () {rightArithShift(true, 'foo')}, error.UnsupportedTypeError);
assert.throws(function () {rightArithShift('foo', true)}, error.UnsupportedTypeError);
assert.throws(function () {rightArithShift(true, undefined)}, error.UnsupportedTypeError);
assert.throws(function () {rightArithShift(undefined, true)}, error.UnsupportedTypeError);
});
});

26
test/function/bitwise/rightLogShift.test.js
View File

@ -38,14 +38,6 @@ describe('rightLogShift', function () {
assert.equal(rightLogShift(null, 1), 0);
});
it('should right logically shift by values given by strings', function () {
assert.equal(rightLogShift('0', '1000'), 0);
assert.equal(rightLogShift('2', 0), 2);
assert.equal(rightLogShift(22, '3'), 2);
assert.equal(rightLogShift('-256', 2), 1073741760);
assert.equal(rightLogShift('-256', '1e2'), 268435440);
});
it('should throw an error if the parameters are not integers', function () {
assert.throws(function () {
rightLogShift(1.1, 1);
@ -56,15 +48,6 @@ describe('rightLogShift', function () {
assert.throws(function () {
rightLogShift(1.1, 1.1);
}, /Parameters in function rightLogShift must be integer numbers/);
assert.throws(function () {
rightLogShift('1.1', '1.1');
}, /Parameters in function rightLogShift must be integer numbers/);
assert.throws(function () {
rightLogShift('1.1', 1);
}, /Parameters in function rightLogShift must be integer numbers/);
assert.throws(function () {
rightLogShift(1, '1.1');
}, /Parameters in function rightLogShift must be integer numbers/);
});
it('should throw an error if used with a unit', function() {
@ -98,4 +81,13 @@ describe('rightLogShift', function () {
assert.throws(function () {rightLogShift(1, 2, 3)}, error.ArgumentsError);
});
it('should throw an error in case of invalid type of arguments', function () {
assert.throws(function () {rightLogShift(new Date(), true)}, error.UnsupportedTypeError);
assert.throws(function () {rightLogShift(true, new Date())}, error.UnsupportedTypeError);
assert.throws(function () {rightLogShift(true, 'foo')}, error.UnsupportedTypeError);
assert.throws(function () {rightLogShift('foo', true)}, error.UnsupportedTypeError);
assert.throws(function () {rightLogShift(true, undefined)}, error.UnsupportedTypeError);
assert.throws(function () {rightLogShift(undefined, true)}, error.UnsupportedTypeError);
});
});

15
test/function/logical/and.test.js
View File

@ -137,15 +137,18 @@ describe('and', function () {
assert.deepEqual(and(matrix([0, 2]), 10), matrix([false, true]));
});
it('should throw an error in case of invalid type if arguments', function () {
assert.throws(function () {and(new Date(), new Date())}, TypeError);
assert.throws(function () {and(2, '23')}, TypeError);
assert.throws(function () {and(2, undefined)}, TypeError);
});
it('should throw an error in case of invalid number of arguments', function () {
assert.throws(function () {and(1)}, error.ArgumentsError);
assert.throws(function () {and(1, 2, 3)}, error.ArgumentsError);
});
it('should throw an error in case of invalid type of arguments', function () {
assert.throws(function () {and(new Date(), true)}, error.UnsupportedTypeError);
assert.throws(function () {and(true, new Date())}, error.UnsupportedTypeError);
assert.throws(function () {and(true, 'foo')}, error.UnsupportedTypeError);
assert.throws(function () {and('foo', true)}, error.UnsupportedTypeError);
assert.throws(function () {and(true, undefined)}, error.UnsupportedTypeError);
assert.throws(function () {and(undefined, true)}, error.UnsupportedTypeError);
});
});

12
test/function/logical/not.test.js
View File

@ -71,15 +71,15 @@ describe('not', function () {
assert.deepEqual(not(matrix([])), matrix([]));
});
it('should throw an error in case of invalid type if arguments', function () {
assert.throws(function () {not(new Date())}, TypeError);
assert.throws(function () {not('23')}, TypeError);
assert.throws(function () {not({})}, TypeError);
});
it('should throw an error in case of invalid number of arguments', function () {
assert.throws(function () {not()}, error.ArgumentsError);
assert.throws(function () {not(1, 2)}, error.ArgumentsError);
});
it('should throw an error in case of invalid type if arguments', function () {
assert.throws(function () {not(new Date())}, error.UnsupportedTypeError);
assert.throws(function () {not('23')}, error.UnsupportedTypeError);
assert.throws(function () {not({})}, error.UnsupportedTypeError);
});
});

15
test/function/logical/or.test.js
View File

@ -161,15 +161,18 @@ describe('or', function () {
assert.deepEqual(or(matrix([0, 2]), 0), matrix([false, true]));
});
it('should throw an error in case of invalid type if arguments', function () {
assert.throws(function () {or(new Date(), new Date())}, TypeError);
assert.throws(function () {or(2, '23')}, TypeError);
assert.throws(function () {or(2, undefined)}, TypeError);
});
it('should throw an error in case of invalid number of arguments', function () {
assert.throws(function () {or(1)}, error.ArgumentsError);
assert.throws(function () {or(1, 2, 3)}, error.ArgumentsError);
});
it('should throw an error in case of invalid type of arguments', function () {
assert.throws(function () {or(new Date(), true)}, error.UnsupportedTypeError);
assert.throws(function () {or(true, new Date())}, error.UnsupportedTypeError);
assert.throws(function () {or(true, 'foo')}, error.UnsupportedTypeError);
assert.throws(function () {or('foo', true)}, error.UnsupportedTypeError);
assert.throws(function () {or(true, undefined)}, error.UnsupportedTypeError);
assert.throws(function () {or(undefined, true)}, error.UnsupportedTypeError);
});
});

15
test/function/logical/xor.test.js
View File

@ -157,15 +157,18 @@ describe('xor', function () {
assert.deepEqual(xor(matrix([0, 2]), 0), matrix([false, true]));
});
it('should throw an error in case of invalid type if arguments', function () {
assert.throws(function () {xor(new Date(), new Date())}, TypeError);
assert.throws(function () {xor(2, '23')}, TypeError);
assert.throws(function () {xor(2, undefined)}, TypeError);
});
it('should throw an error in case of invalid number of arguments', function () {
assert.throws(function () {xor(1)}, error.ArgumentsError);
assert.throws(function () {xor(1, 2, 3)}, error.ArgumentsError);
});
it('should throw an error in case of invalid type of arguments', function () {
assert.throws(function () {xor(new Date(), true)}, error.UnsupportedTypeError);
assert.throws(function () {xor(true, new Date())}, error.UnsupportedTypeError);
assert.throws(function () {xor(true, 'foo')}, error.UnsupportedTypeError);
assert.throws(function () {xor('foo', true)}, error.UnsupportedTypeError);
assert.throws(function () {xor(true, undefined)}, error.UnsupportedTypeError);
assert.throws(function () {xor(undefined, true)}, error.UnsupportedTypeError);
});
});