CoCalc -- arithmetic-test.js

Summer of Sage Days 2015: San Diego (sd64.25), etc.
react / wstein / node_modules / browserify / node_modules / crypto-browserify / node_modules / create-ecdh / node_modules / bn.js / test / arithmetic-test.js
⁸⁰⁵⁵⁹ views
1
var assert = require('assert');
2
var BN = require('../').BN;
3
var fixtures = require('./fixtures');
4

5
describe('BN.js/Arithmetic', function() {
6
  describe('.add()', function() {
7
    it('should add numbers', function() {
8
      assert.equal(new BN(14).add(new BN(26)).toString(16), '28');
9
      var k = new BN(0x1234);
10
      var r = k;
11
      for (var i = 0; i < 257; i++)
12
        r = r.add(k);
13
      assert.equal(r.toString(16), '125868');
14
    });
15

16
    it('should handle carry properly (in-place)', function() {
17
      var k = new BN('abcdefabcdefabcdef', 16);
18
      var r = new BN('deadbeef', 16);
19
      for (var i = 0; i < 257; i++)
20
        r.iadd(k);
21
      assert.equal(r.toString(16), 'ac79bd9b79be7a277bde');
22
    });
23

24
    it('should properly do positive + negative', function() {
25
      var a = new BN('abcd', 16);
26
      var b = new BN('-abce', 16);
27

28
      assert.equal(a.iadd(b).toString(16), '-1');
29

30
      var a = new BN('abcd', 16);
31
      var b = new BN('-abce', 16);
32

33
      assert.equal(a.add(b).toString(16), '-1');
34
      assert.equal(b.add(a).toString(16), '-1');
35
    });
36
  });
37

38
  describe('.iaddn()', function() {
39
    it('should allow a sign change', function() {
40
      var a = new BN(-100);
41
      assert.equal(a.sign, true);
42

43
      a.iaddn(200);
44

45
      assert.equal(a.sign, false);
46
      assert.equal(a.toString(), '100');
47
    });
48

49
    it('should add negative number', function() {
50
      var a = new BN(-100);
51
      assert.equal(a.sign, true);
52

53
      a.iaddn(-200);
54

55
      assert.equal(a.toString(), '-300');
56
    });
57

58
    it('should allow neg + pos with big number', function() {
59
      var a = new BN('-1000000000', 10);
60
      assert.equal(a.sign, true);
61

62
      a.iaddn(200);
63

64
      assert.equal(a.toString(), '-999999800');
65
    });
66

67
    it('should carry limb', function() {
68
      var a = new BN('3ffffff', 16);
69

70
      assert.equal(a.iaddn(1).toString(16), '4000000');
71
    });
72
  });
73

74
  describe('.sub()', function() {
75
    it('should subtract small numbers', function() {
76
      assert.equal(new BN(26).sub(new BN(14)).toString(16), 'c');
77
      assert.equal(new BN(14).sub(new BN(26)).toString(16), '-c');
78
      assert.equal(new BN(26).sub(new BN(26)).toString(16), '0');
79
      assert.equal(new BN(-26).sub(new BN(26)).toString(16), '-34');
80
    });
81

82
    var a = new BN(
83
      '31ff3c61db2db84b9823d320907a573f6ad37c437abe458b1802cda041d6384' +
84
          'a7d8daef41395491e2',
85
      16);
86
    var b = new BN(
87
      '6f0e4d9f1d6071c183677f601af9305721c91d31b0bbbae8fb790000',
88
      16);
89
    var r = new BN(
90
      '31ff3c61db2db84b9823d3208989726578fd75276287cd9516533a9acfb9a67' +
91
          '76281f34583ddb91e2',
92
      16);
93

94
    it('should subtract big numbers', function() {
95
      assert.equal(a.sub(b).cmp(r), 0);
96
    });
97

98
    it('should subtract numbers in place', function() {
99
      assert.equal(b.clone().isub(a).neg().cmp(r), 0);
100
    });
101

102
    it('should subtract with carry', function() {
103
      // Carry and copy
104
      var a = new BN('12345', 16);
105
      var b = new BN('1000000000000', 16);
106
      assert.equal(a.isub(b).toString(16), '-fffffffedcbb');
107

108
      var a = new BN('12345', 16);
109
      var b = new BN('1000000000000', 16);
110
      assert.equal(b.isub(a).toString(16), 'fffffffedcbb');
111
    });
112
  });
113

114
  describe('.isubn()', function() {
115
    it('should subtract negative number', function() {
116
      var r = new BN(
117
        '7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b', 16);
118
      assert.equal(r.isubn(-1).toString(16),
119
        '7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681c');
120
    });
121

122
    it('should work for positive numbers', function() {
123
      var a = new BN(-100);
124
      assert.equal(a.sign, true);
125

126
      a.isubn(200);
127
      assert.equal(a.sign, true);
128
      assert.equal(a.toString(), '-300');
129
    });
130

131
    it('should not allow a sign change', function() {
132
      var a = new BN(-100);
133
      assert.equal(a.sign, true);
134

135
      a.isubn(-200);
136
      assert.equal(a.sign, false);
137
      assert.equal(a.toString(), '100');
138
    });
139
  });
140

141
  describe('.mul()', function() {
142
    it('should multiply numbers of different signs', function() {
143
      assert.equal(new BN(0x1001).mul(new BN(0x1234)).toString(16),
144
                   '1235234');
145
      assert.equal(new BN(-0x1001).mul(new BN(0x1234)).toString(16),
146
                   '-1235234');
147
      assert.equal(new BN(-0x1001).mul(new BN(-0x1234)).toString(16),
148
                   '1235234');
149
    });
150

151
    it('should multiply with carry', function() {
152
      var n = new BN(0x1001);
153
      var r = n;
154
      for (var i = 0; i < 4; i++)
155
        r = r.mul(n);
156
      assert.equal(r.toString(16),
157
                   '100500a00a005001');
158
    });
159

160
    it('should correctly multiply big numbers', function() {
161
      var n = new BN(
162
        '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
163
        16
164
      );
165
      assert.equal(
166
        n.mul(n).toString(16),
167
        '39e58a8055b6fb264b75ec8c646509784204ac15a8c24e05babc9729ab9' +
168
            'b055c3a9458e4ce3289560a38e08ba8175a9446ce14e608245ab3a9' +
169
            '978a8bd8acaa40');
170
      assert.equal(
171
        n.mul(n).mul(n).toString(16),
172
        '1b888e01a06e974017a28a5b4da436169761c9730b7aeedf75fc60f687b' +
173
            '46e0cf2cb11667f795d5569482640fe5f628939467a01a612b02350' +
174
            '0d0161e9730279a7561043af6197798e41b7432458463e64fa81158' +
175
            '907322dc330562697d0d600');
176
    });
177

178
    it('should multiply neg number on 0', function() {
179
      assert.equal(
180
        new BN('-100000000000').mul(new BN('3').div(new BN('4'))).toString(16),
181
        '0'
182
      );
183
    });
184

185
    it('should regress mul big numbers', function() {
186
      var q = fixtures.dhGroups.p17.q;
187
      var qs = fixtures.dhGroups.p17.qs;
188

189
      var q = new BN(q, 16);
190
      assert.equal(q.sqr().toString(16), qs);
191
      assert.equal(q.isqr().toString(16), qs);
192
    });
193
  });
194

195
  describe('.imul()', function() {
196
    it('should multiply numbers in-place', function() {
197
      var a = new BN('abcdef01234567890abcd', 16);
198
      var b = new BN('deadbeefa551edebabba8', 16);
199
      var c = a.mul(b);
200

201
      assert.equal(a.imul(b).toString(16), c.toString(16));
202

203
      var a = new BN('abcdef01234567890abcd214a25123f512361e6d236', 16);
204
      var b = new BN('deadbeefa551edebabba8121234fd21bac0341324dd', 16);
205
      var c = a.mul(b);
206

207
      assert.equal(a.imul(b).toString(16), c.toString(16));
208
    });
209

210
    it('should multiply by 0', function() {
211
      var a = new BN('abcdef01234567890abcd', 16);
212
      var b = new BN('0', 16);
213
      var c = a.mul(b);
214

215
      assert.equal(a.imul(b).toString(16), c.toString(16));
216
    });
217
  });
218

219
  describe('.div()', function() {
220
    it('should divide numbers', function() {
221
      assert.equal(new BN('10').div(new BN(256)).toString(16),
222
                   '0');
223
      assert.equal(new BN('69527932928').div(new BN('16974594')).toString(16),
224
                   'fff');
225
      assert.equal(new BN('-69527932928').div(new BN('16974594')).toString(16),
226
                   '-fff');
227

228
      var b = new BN(
229
        '39e58a8055b6fb264b75ec8c646509784204ac15a8c24e05babc9729ab9' +
230
            'b055c3a9458e4ce3289560a38e08ba8175a9446ce14e608245ab3a9' +
231
            '978a8bd8acaa40',
232
        16);
233
      var n = new BN(
234
        '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
235
        16
236
      );
237
      assert.equal(b.div(n).toString(16), n.toString(16));
238

239
      assert.equal(new BN('1').div(new BN('-5')).toString(10), '0');
240
    });
241

242
    it('should not fail on regression after moving to _wordDiv', function() {
243
      // Regression after moving to word div
244
      var p = new BN(
245
        'fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f',
246
        16);
247
      var a = new BN(
248
        '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
249
        16);
250
      var as = a.sqr();
251
      assert.equal(
252
          as.div(p).toString(16),
253
          '39e58a8055b6fb264b75ec8c646509784204ac15a8c24e05babc9729e58090b9');
254

255
      var p = new BN(
256
        'ffffffff00000001000000000000000000000000ffffffffffffffffffffffff',
257
        16);
258
      var a = new BN(
259
        'fffffffe00000003fffffffd0000000200000001fffffffe00000002ffffffff' +
260
        'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
261
        16);
262
      assert.equal(
263
        a.div(p).toString(16),
264
        'ffffffff00000002000000000000000000000001000000000000000000000001');
265
    });
266
  });
267

268
  describe('.idivn()', function() {
269
    it('should divide numbers in-place', function() {
270
      assert.equal(new BN('10', 16).idivn(3).toString(16), '5');
271
      assert.equal(new BN('12', 16).idivn(3).toString(16), '6');
272
      assert.equal(new BN('10000000000000000').idivn(3).toString(10),
273
                   '3333333333333333');
274
      assert.equal(
275
          new BN('100000000000000000000000000000').idivn(3).toString(10),
276
          '33333333333333333333333333333');
277

278
      var t = new BN(3);
279
      assert.equal(
280
          new BN('12345678901234567890123456', 16).idivn(3).toString(16),
281
          new BN('12345678901234567890123456', 16).div(t).toString(16));
282
    });
283
  });
284

285
  describe('.divRound()', function() {
286
    it('should divide numbers with rounding', function() {
287
      assert.equal(new BN(9).divRound(new BN(20)).toString(10),
288
                   '0');
289
      assert.equal(new BN(10).divRound(new BN(20)).toString(10),
290
                   '1');
291
      assert.equal(new BN(150).divRound(new BN(20)).toString(10),
292
                   '8');
293
      assert.equal(new BN(149).divRound(new BN(20)).toString(10),
294
                   '7');
295
      assert.equal(new BN(149).divRound(new BN(17)).toString(10),
296
                   '9');
297
      assert.equal(new BN(144).divRound(new BN(17)).toString(10),
298
                   '8');
299
      assert.equal(new BN(-144).divRound(new BN(17)).toString(10),
300
                   '-8');
301
    });
302

303
    it('should return 1 on exact division', function() {
304
      assert.equal(new BN(144).divRound(new BN(144)).toString(10), '1');
305
    });
306
  });
307

308
  describe('.mod()', function() {
309
    it('should mod numbers', function() {
310
      assert.equal(new BN('10').mod(new BN(256)).toString(16),
311
                   'a');
312
      assert.equal(new BN('69527932928').mod(new BN('16974594')).toString(16),
313
                   '102f302');
314
      assert.equal(new BN('-69527932928').mod(new BN('16974594')).toString(16),
315
                   '1000');
316

317
      var p = new BN(
318
        'ffffffff00000001000000000000000000000000ffffffffffffffffffffffff',
319
        16);
320
      var a = new BN(
321
        'fffffffe00000003fffffffd0000000200000001fffffffe00000002ffffffff' +
322
        'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff',
323
        16);
324
      assert.equal(
325
        a.mod(p).toString(16),
326
        '0');
327
    });
328

329
    it('should properly carry the sign inside division', function() {
330
      var a = new BN('945304eb96065b2a98b57a48a06ae28d285a71b5', 'hex');
331
      var b = new BN(
332
        'fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe',
333
        'hex');
334

335
      assert.equal(a.mul(b).mod(a).cmpn(0), 0);
336
    });
337
  });
338

339
  describe('.modn()', function() {
340
    it('should act like .mod() on small numbers', function() {
341
      assert.equal(new BN('10', 16).modn(256).toString(16), '10');
342
      assert.equal(new BN('100', 16).modn(256).toString(16), '0');
343
      assert.equal(new BN('1001', 16).modn(256).toString(16), '1');
344
      assert.equal(new BN('100000000001', 16).modn(256).toString(16), '1');
345
      assert.equal(new BN('100000000001', 16).modn(257).toString(16),
346
                   new BN('100000000001', 16).mod(new BN(257)).toString(16));
347
      assert.equal(new BN('123456789012', 16).modn(3).toString(16),
348
                   new BN('123456789012', 16).mod(new BN(3)).toString(16));
349
    });
350
  });
351

352
  describe('.abs()', function() {
353
    it('should return absolute value', function() {
354
      assert.equal(new BN(0x1001).abs().toString(), '4097');
355
      assert.equal(new BN(-0x1001).abs().toString(), '4097');
356
      assert.equal(new BN('ffffffff', 16).abs().toString(), '4294967295');
357
    })
358
  });
359

360
  describe('.invm()', function() {
361
    it('should invert relatively-prime numbers', function() {
362
      var p = new BN(257);
363
      var a = new BN(3);
364
      var b = a.invm(p);
365
      assert.equal(a.mul(b).mod(p).toString(16), '1');
366

367
      var p192 = new BN(
368
          'fffffffffffffffffffffffffffffffeffffffffffffffff',
369
          16);
370
      var a = new BN('deadbeef', 16);
371
      var b = a.invm(p192);
372
      assert.equal(a.mul(b).mod(p192).toString(16), '1');
373

374
      // Even base
375
      var phi = new BN('872d9b030ba368706b68932cf07a0e0c', 16);
376
      var e = new BN(65537);
377
      var d = e.invm(phi);
378
      assert.equal(e.mul(d).mod(phi).toString(16), '1');
379

380
      // Even base (take #2)
381
      var a = new BN('5');
382
      var b = new BN('6');
383
      var r = a.invm(b);
384
      assert.equal(r.mul(a).mod(b).toString(16), '1');
385
    });
386
  });
387

388
  describe('.gcd()', function() {
389
    it('should return GCD', function() {
390
      assert.equal(new BN(3).gcd(new BN(2)).toString(16), '1');
391
      assert.equal(new BN(18).gcd(new BN(12)).toString(16), '6');
392
      assert.equal(new BN(-18).gcd(new BN(12)).toString(16), '6');
393
    });
394
  });
395
});
396

397
Product

Resources

Company
