1 | function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
|
2 |
|
3 | function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
|
4 |
|
5 | function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
6 |
|
7 | import { factory } from '../../utils/factory';
|
8 | import { deepMap } from '../../utils/collection';
|
9 | import { isInteger } from '../../utils/number';
|
10 | import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11';
|
11 | import { createAlgorithm12 } from '../../type/matrix/utils/algorithm12';
|
12 | import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14';
|
13 | import { roundNumber } from '../../plain/number';
|
14 | var NO_INT = 'Number of decimals in function round must be an integer';
|
15 | var name = 'round';
|
16 | var dependencies = ['typed', 'matrix', 'equalScalar', 'zeros', 'BigNumber', 'DenseMatrix'];
|
17 | export var createRound =
|
18 |
|
19 | factory(name, dependencies, function (_ref) {
|
20 | var typed = _ref.typed,
|
21 | matrix = _ref.matrix,
|
22 | equalScalar = _ref.equalScalar,
|
23 | zeros = _ref.zeros,
|
24 | BigNumber = _ref.BigNumber,
|
25 | DenseMatrix = _ref.DenseMatrix;
|
26 | var algorithm11 = createAlgorithm11({
|
27 | typed: typed,
|
28 | equalScalar: equalScalar
|
29 | });
|
30 | var algorithm12 = createAlgorithm12({
|
31 | typed: typed,
|
32 | DenseMatrix: DenseMatrix
|
33 | });
|
34 | var algorithm14 = createAlgorithm14({
|
35 | typed: typed
|
36 | });
|
37 | |
38 |
|
39 |
|
40 |
|
41 |
|
42 |
|
43 |
|
44 |
|
45 |
|
46 |
|
47 |
|
48 |
|
49 |
|
50 |
|
51 |
|
52 |
|
53 |
|
54 |
|
55 |
|
56 |
|
57 |
|
58 |
|
59 |
|
60 |
|
61 |
|
62 |
|
63 |
|
64 |
|
65 |
|
66 |
|
67 |
|
68 |
|
69 | var round = typed(name, _objectSpread({}, roundNumberSignatures, {
|
70 | Complex: function Complex(x) {
|
71 | return x.round();
|
72 | },
|
73 | 'Complex, number': function ComplexNumber(x, n) {
|
74 | if (n % 1) {
|
75 | throw new TypeError(NO_INT);
|
76 | }
|
77 |
|
78 | return x.round(n);
|
79 | },
|
80 | 'Complex, BigNumber': function ComplexBigNumber(x, n) {
|
81 | if (!n.isInteger()) {
|
82 | throw new TypeError(NO_INT);
|
83 | }
|
84 |
|
85 | var _n = n.toNumber();
|
86 |
|
87 | return x.round(_n);
|
88 | },
|
89 | 'number, BigNumber': function numberBigNumber(x, n) {
|
90 | if (!n.isInteger()) {
|
91 | throw new TypeError(NO_INT);
|
92 | }
|
93 |
|
94 | return new BigNumber(x).toDecimalPlaces(n.toNumber());
|
95 | },
|
96 | BigNumber: function BigNumber(x) {
|
97 | return x.toDecimalPlaces(0);
|
98 | },
|
99 | 'BigNumber, BigNumber': function BigNumberBigNumber(x, n) {
|
100 | if (!n.isInteger()) {
|
101 | throw new TypeError(NO_INT);
|
102 | }
|
103 |
|
104 | return x.toDecimalPlaces(n.toNumber());
|
105 | },
|
106 | Fraction: function Fraction(x) {
|
107 | return x.round();
|
108 | },
|
109 | 'Fraction, number': function FractionNumber(x, n) {
|
110 | if (n % 1) {
|
111 | throw new TypeError(NO_INT);
|
112 | }
|
113 |
|
114 | return x.round(n);
|
115 | },
|
116 | 'Array | Matrix': function ArrayMatrix(x) {
|
117 |
|
118 | return deepMap(x, round, true);
|
119 | },
|
120 | 'SparseMatrix, number | BigNumber': function SparseMatrixNumberBigNumber(x, y) {
|
121 | return algorithm11(x, y, round, false);
|
122 | },
|
123 | 'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
|
124 | return algorithm14(x, y, round, false);
|
125 | },
|
126 | 'number | Complex | BigNumber, SparseMatrix': function numberComplexBigNumberSparseMatrix(x, y) {
|
127 |
|
128 | if (equalScalar(x, 0)) {
|
129 |
|
130 | return zeros(y.size(), y.storage());
|
131 | }
|
132 |
|
133 | return algorithm12(y, x, round, true);
|
134 | },
|
135 | 'number | Complex | BigNumber, DenseMatrix': function numberComplexBigNumberDenseMatrix(x, y) {
|
136 |
|
137 | if (equalScalar(x, 0)) {
|
138 |
|
139 | return zeros(y.size(), y.storage());
|
140 | }
|
141 |
|
142 | return algorithm14(y, x, round, true);
|
143 | },
|
144 | 'Array, number | BigNumber': function ArrayNumberBigNumber(x, y) {
|
145 |
|
146 | return algorithm14(matrix(x), y, round, false).valueOf();
|
147 | },
|
148 | 'number | Complex | BigNumber, Array': function numberComplexBigNumberArray(x, y) {
|
149 |
|
150 | return algorithm14(matrix(y), x, round, true).valueOf();
|
151 | }
|
152 | }));
|
153 | return round;
|
154 | });
|
155 | var roundNumberSignatures = {
|
156 | number: roundNumber,
|
157 | 'number, number': function numberNumber(x, n) {
|
158 | if (!isInteger(n)) {
|
159 | throw new TypeError(NO_INT);
|
160 | }
|
161 |
|
162 | if (n < 0 || n > 15) {
|
163 | throw new Error('Number of decimals in function round must be in te range of 0-15');
|
164 | }
|
165 |
|
166 | return roundNumber(x, n);
|
167 | }
|
168 | };
|
169 | export var createRoundNumber =
|
170 |
|
171 | factory(name, ['typed'], function (_ref2) {
|
172 | var typed = _ref2.typed;
|
173 | return typed(name, roundNumberSignatures);
|
174 | }); |
\ | No newline at end of file |