UNPKG

5.34 kBJavaScriptView Raw
1import { factory } from '../../utils/factory.js';
2import { createAlgorithm03 } from '../../type/matrix/utils/algorithm03.js';
3import { createAlgorithm07 } from '../../type/matrix/utils/algorithm07.js';
4import { createAlgorithm12 } from '../../type/matrix/utils/algorithm12.js';
5import { createAlgorithm13 } from '../../type/matrix/utils/algorithm13.js';
6import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
7var name = 'equal';
8var dependencies = ['typed', 'matrix', 'equalScalar', 'DenseMatrix'];
9export var createEqual = /* #__PURE__ */factory(name, dependencies, _ref => {
10 var {
11 typed,
12 matrix,
13 equalScalar,
14 DenseMatrix
15 } = _ref;
16 var algorithm03 = createAlgorithm03({
17 typed
18 });
19 var algorithm07 = createAlgorithm07({
20 typed,
21 DenseMatrix
22 });
23 var algorithm12 = createAlgorithm12({
24 typed,
25 DenseMatrix
26 });
27 var algorithm13 = createAlgorithm13({
28 typed
29 });
30 var algorithm14 = createAlgorithm14({
31 typed
32 });
33 /**
34 * Test whether two values are equal.
35 *
36 * The function tests whether the relative difference between x and y is
37 * smaller than the configured epsilon. The function cannot be used to
38 * compare values smaller than approximately 2.22e-16.
39 *
40 * For matrices, the function is evaluated element wise.
41 * In case of complex numbers, x.re must equal y.re, and x.im must equal y.im.
42 *
43 * Values `null` and `undefined` are compared strictly, thus `null` is only
44 * equal to `null` and nothing else, and `undefined` is only equal to
45 * `undefined` and nothing else. Strings are compared by their numerical value.
46 *
47 * Syntax:
48 *
49 * math.equal(x, y)
50 *
51 * Examples:
52 *
53 * math.equal(2 + 2, 3) // returns false
54 * math.equal(2 + 2, 4) // returns true
55 *
56 * const a = math.unit('50 cm')
57 * const b = math.unit('5 m')
58 * math.equal(a, b) // returns true
59 *
60 * const c = [2, 5, 1]
61 * const d = [2, 7, 1]
62 *
63 * math.equal(c, d) // returns [true, false, true]
64 * math.deepEqual(c, d) // returns false
65 *
66 * math.equal("1000", "1e3") // returns true
67 * math.equal(0, null) // returns false
68 *
69 * See also:
70 *
71 * unequal, smaller, smallerEq, larger, largerEq, compare, deepEqual, equalText
72 *
73 * @param {number | BigNumber | boolean | Complex | Unit | string | Array | Matrix} x First value to compare
74 * @param {number | BigNumber | boolean | Complex | Unit | string | Array | Matrix} y Second value to compare
75 * @return {boolean | Array | Matrix} Returns true when the compared values are equal, else returns false
76 */
77
78 return typed(name, {
79 'any, any': function anyAny(x, y) {
80 // strict equality for null and undefined?
81 if (x === null) {
82 return y === null;
83 }
84
85 if (y === null) {
86 return x === null;
87 }
88
89 if (x === undefined) {
90 return y === undefined;
91 }
92
93 if (y === undefined) {
94 return x === undefined;
95 }
96
97 return equalScalar(x, y);
98 },
99 'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
100 return algorithm07(x, y, equalScalar);
101 },
102 'SparseMatrix, DenseMatrix': function SparseMatrixDenseMatrix(x, y) {
103 return algorithm03(y, x, equalScalar, true);
104 },
105 'DenseMatrix, SparseMatrix': function DenseMatrixSparseMatrix(x, y) {
106 return algorithm03(x, y, equalScalar, false);
107 },
108 'DenseMatrix, DenseMatrix': function DenseMatrixDenseMatrix(x, y) {
109 return algorithm13(x, y, equalScalar);
110 },
111 'Array, Array': function ArrayArray(x, y) {
112 // use matrix implementation
113 return this(matrix(x), matrix(y)).valueOf();
114 },
115 'Array, Matrix': function ArrayMatrix(x, y) {
116 // use matrix implementation
117 return this(matrix(x), y);
118 },
119 'Matrix, Array': function MatrixArray(x, y) {
120 // use matrix implementation
121 return this(x, matrix(y));
122 },
123 'SparseMatrix, any': function SparseMatrixAny(x, y) {
124 return algorithm12(x, y, equalScalar, false);
125 },
126 'DenseMatrix, any': function DenseMatrixAny(x, y) {
127 return algorithm14(x, y, equalScalar, false);
128 },
129 'any, SparseMatrix': function anySparseMatrix(x, y) {
130 return algorithm12(y, x, equalScalar, true);
131 },
132 'any, DenseMatrix': function anyDenseMatrix(x, y) {
133 return algorithm14(y, x, equalScalar, true);
134 },
135 'Array, any': function ArrayAny(x, y) {
136 // use matrix implementation
137 return algorithm14(matrix(x), y, equalScalar, false).valueOf();
138 },
139 'any, Array': function anyArray(x, y) {
140 // use matrix implementation
141 return algorithm14(matrix(y), x, equalScalar, true).valueOf();
142 }
143 });
144});
145export var createEqualNumber = factory(name, ['typed', 'equalScalar'], _ref2 => {
146 var {
147 typed,
148 equalScalar
149 } = _ref2;
150 return typed(name, {
151 'any, any': function anyAny(x, y) {
152 // strict equality for null and undefined?
153 if (x === null) {
154 return y === null;
155 }
156
157 if (y === null) {
158 return x === null;
159 }
160
161 if (x === undefined) {
162 return y === undefined;
163 }
164
165 if (y === undefined) {
166 return x === undefined;
167 }
168
169 return equalScalar(x, y);
170 }
171 });
172});
\No newline at end of file