141 lines
3.8 KiB
JavaScript
141 lines
3.8 KiB
JavaScript
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.createOnes = void 0;
|
|
|
|
var _is = require("../../utils/is.js");
|
|
|
|
var _number = require("../../utils/number.js");
|
|
|
|
var _array = require("../../utils/array.js");
|
|
|
|
var _factory = require("../../utils/factory.js");
|
|
|
|
var name = 'ones';
|
|
var dependencies = ['typed', 'config', 'matrix', 'BigNumber'];
|
|
var createOnes = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
|
|
var typed = _ref.typed,
|
|
config = _ref.config,
|
|
matrix = _ref.matrix,
|
|
BigNumber = _ref.BigNumber;
|
|
|
|
/**
|
|
* Create a matrix filled with ones. The created matrix can have one or
|
|
* multiple dimensions.
|
|
*
|
|
* Syntax:
|
|
*
|
|
* math.ones(m)
|
|
* math.ones(m, format)
|
|
* math.ones(m, n)
|
|
* math.ones(m, n, format)
|
|
* math.ones([m, n])
|
|
* math.ones([m, n], format)
|
|
* math.ones([m, n, p, ...])
|
|
* math.ones([m, n, p, ...], format)
|
|
*
|
|
* Examples:
|
|
*
|
|
* math.ones(3) // returns [1, 1, 1]
|
|
* math.ones(3, 2) // returns [[1, 1], [1, 1], [1, 1]]
|
|
* math.ones(3, 2, 'dense') // returns Dense Matrix [[1, 1], [1, 1], [1, 1]]
|
|
*
|
|
* const A = [[1, 2, 3], [4, 5, 6]]
|
|
* math.ones(math.size(A)) // returns [[1, 1, 1], [1, 1, 1]]
|
|
*
|
|
* See also:
|
|
*
|
|
* zeros, identity, size, range
|
|
*
|
|
* @param {...number | Array} size The size of each dimension of the matrix
|
|
* @param {string} [format] The Matrix storage format
|
|
*
|
|
* @return {Array | Matrix | number} A matrix filled with ones
|
|
*/
|
|
return typed('ones', {
|
|
'': function _() {
|
|
return config.matrix === 'Array' ? _ones([]) : _ones([], 'default');
|
|
},
|
|
// math.ones(m, n, p, ..., format)
|
|
// TODO: more accurate signature '...number | BigNumber, string' as soon as typed-function supports this
|
|
'...number | BigNumber | string': function numberBigNumberString(size) {
|
|
var last = size[size.length - 1];
|
|
|
|
if (typeof last === 'string') {
|
|
var format = size.pop();
|
|
return _ones(size, format);
|
|
} else if (config.matrix === 'Array') {
|
|
return _ones(size);
|
|
} else {
|
|
return _ones(size, 'default');
|
|
}
|
|
},
|
|
Array: _ones,
|
|
Matrix: function Matrix(size) {
|
|
var format = size.storage();
|
|
return _ones(size.valueOf(), format);
|
|
},
|
|
'Array | Matrix, string': function ArrayMatrixString(size, format) {
|
|
return _ones(size.valueOf(), format);
|
|
}
|
|
});
|
|
/**
|
|
* Create an Array or Matrix with ones
|
|
* @param {Array} size
|
|
* @param {string} [format='default']
|
|
* @return {Array | Matrix}
|
|
* @private
|
|
*/
|
|
|
|
function _ones(size, format) {
|
|
var hasBigNumbers = _normalize(size);
|
|
|
|
var defaultValue = hasBigNumbers ? new BigNumber(1) : 1;
|
|
|
|
_validate(size);
|
|
|
|
if (format) {
|
|
// return a matrix
|
|
var m = matrix(format);
|
|
|
|
if (size.length > 0) {
|
|
return m.resize(size, defaultValue);
|
|
}
|
|
|
|
return m;
|
|
} else {
|
|
// return an Array
|
|
var arr = [];
|
|
|
|
if (size.length > 0) {
|
|
return (0, _array.resize)(arr, size, defaultValue);
|
|
}
|
|
|
|
return arr;
|
|
}
|
|
} // replace BigNumbers with numbers, returns true if size contained BigNumbers
|
|
|
|
|
|
function _normalize(size) {
|
|
var hasBigNumbers = false;
|
|
size.forEach(function (value, index, arr) {
|
|
if ((0, _is.isBigNumber)(value)) {
|
|
hasBigNumbers = true;
|
|
arr[index] = value.toNumber();
|
|
}
|
|
});
|
|
return hasBigNumbers;
|
|
} // validate arguments
|
|
|
|
|
|
function _validate(size) {
|
|
size.forEach(function (value) {
|
|
if (typeof value !== 'number' || !(0, _number.isInteger)(value) || value < 0) {
|
|
throw new Error('Parameters in function ones must be positive integers');
|
|
}
|
|
});
|
|
}
|
|
});
|
|
exports.createOnes = createOnes; |