blob: 78b5cc5747beadc1543d209a3bb7c3dc06446037 [file] [log] [blame]
// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
/*
* Copyright (c) 2003-2005 Tom Wu
* Copyright (c) 2012 Adam Singer (adam@solvr.io)
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,
* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY
* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.
*
* IN NO EVENT SHALL TOM WU BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
* INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER
* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF
* THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* In addition, the following condition applies:
*
* All redistributions must retain an intact copy of this copyright notice
* and disclaimer.
*/
// A big integer number is represented by a sign, an array of 32-bit unsigned
// integers in little endian format, and a number of used digits in that array.
// The code makes sure that an even number of digits is always accessible and
// meaningful, so that pairs of digits can be processed as 64-bit unsigned
// numbers on a 64-bit platform. This requires the initialization of a leading
// zero if the number of used digits is odd.
class _Bigint extends _IntegerImplementation implements int {
// Bits per digit.
static const int _DIGIT_BITS = 32;
static const int _DIGIT_BASE = 1 << _DIGIT_BITS;
static const int _DIGIT_MASK = (1 << _DIGIT_BITS) - 1;
// Bits per half digit.
static const int _DIGIT2_BITS = _DIGIT_BITS >> 1;
static const int _DIGIT2_MASK = (1 << _DIGIT2_BITS) - 1;
// Min and max of non bigint values.
static const int _MIN_INT64 = (-1) << 63;
static const int _MAX_INT64 = 0x7fffffffffffffff;
// Bigint constant values.
// Note: Not declared as final in order to satisfy optimizer, which expects
// constants to be in canonical form (Smi).
static _Bigint _MINUS_ONE = new _Bigint._fromInt(-1);
static _Bigint _ZERO = new _Bigint._fromInt(0);
static _Bigint _ONE = new _Bigint._fromInt(1);
// Result cache for last _divRem call.
static Uint32List _lastDividend_digits;
static int _lastDividend_used;
static Uint32List _lastDivisor_digits;
static int _lastDivisor_used;
static Uint32List _lastQuoRem_digits;
static int _lastQuoRem_used;
static int _lastRem_used;
static int _lastRem_nsh;
// Internal data structure.
bool get _neg native "Bigint_getNeg";
int get _used native "Bigint_getUsed";
Uint32List get _digits native "Bigint_getDigits";
// Factory returning an instance initialized with the given field values.
// The 'digits' array is first clamped and 'used' is reduced accordingly.
// A leading zero digit may be initialized to guarantee that digit pairs can
// be processed as 64-bit values on 64-bit platforms.
factory _Bigint(bool neg, int used, Uint32List digits)
native "Bigint_allocate";
// Factory returning an instance initialized to an integer value no larger
// than a Mint.
factory _Bigint._fromInt(int i) {
assert(i is! _Bigint);
var neg;
var l, h;
if (i < 0) {
neg = true;
if (i == _MIN_INT64) {
l = 0;
h = 0x80000000;
} else {
l = (-i) & _DIGIT_MASK;
h = (-i) >> _DIGIT_BITS;
}
} else {
neg = false;
l = i & _DIGIT_MASK;
h = i >> _DIGIT_BITS;
}
var digits = new Uint32List(2);
digits[0] = l;
digits[1] = h;
return new _Bigint(neg, 2, digits);
}
// Allocate an array of the given length (+1 for at least one leading zero
// digit if odd) and copy digits[from..to-1] starting at index 0, followed by
// leading zero digits.
static Uint32List _cloneDigits(Uint32List digits, int from, int to,
int length) {
length += length & 1; // Even number of digits.
var r_digits = new Uint32List(length);
var n = to - from;
for (var i = 0; i < n; i++) {
r_digits[i] = digits[from + i];
}
return r_digits;
}
// Return most compact integer (i.e. possibly Smi or Mint).
int _toValidInt() {
assert(_DIGIT_BITS == 32); // Otherwise this code needs to be revised.
var used = _used;
if (used == 0) return 0;
var digits = _digits;
if (used == 1) return _neg ? -digits[0] : digits[0];
if (used > 2) return this;
if (_neg) {
if (digits[1] > 0x80000000) return this;
if (digits[1] == 0x80000000) {
if (digits[0] > 0) return this;
return _MIN_INT64;
}
return -((digits[1] << _DIGIT_BITS) | digits[0]);
}
if (digits[1] >= 0x80000000) return this;
return (digits[1] << _DIGIT_BITS) | digits[0];
}
// Conversion from int to bigint.
_Bigint _toBigint() => this;
// Return -this.
_Bigint _negate() {
var used = _used;
if (used == 0) {
return this;
}
return new _Bigint(!_neg, used, _digits);
}
// Return abs(this).
_Bigint _abs() {
var neg = _neg;
if (!neg) {
return this;
}
return new _Bigint(!neg, _used, _digits);
}
// Return the bit length of digit x.
static int _nbits(int x) {
var r = 1, t;
if ((t = x >> 16) != 0) { x = t; r += 16; }
if ((t = x >> 8) != 0) { x = t; r += 8; }
if ((t = x >> 4) != 0) { x = t; r += 4; }
if ((t = x >> 2) != 0) { x = t; r += 2; }
if ((x >> 1) != 0) { r += 1; }
return r;
}
// Return this << n*_DIGIT_BITS.
_Bigint _dlShift(int n) {
final used = _used;
if (used == 0) {
return _ZERO;
}
final r_used = used + n;
final digits = _digits;
final r_digits = new Uint32List(r_used + (r_used & 1));
var i = used;
while (--i >= 0) {
r_digits[i + n] = digits[i];
}
return new _Bigint(_neg, r_used, r_digits);
}
// r_digits[0..r_used-1] = x_digits[0..x_used-1] << n*_DIGIT_BITS.
// Return r_used.
static int _dlShiftDigits(Uint32List x_digits, int x_used, int n,
Uint32List r_digits) {
if (x_used == 0) {
return 0;
}
if (n == 0 && identical(r_digits, x_digits)) {
return x_used;
}
final r_used = x_used + n;
assert(r_digits.length >= r_used + (r_used & 1));
var i = x_used;
while (--i >= 0) {
r_digits[i + n] = x_digits[i];
}
i = n;
while (--i >= 0) {
r_digits[i] = 0;
}
if (r_used.isOdd) {
r_digits[r_used] = 0;
}
return r_used;
}
// Return this >> n*_DIGIT_BITS.
_Bigint _drShift(int n) {
final used = _used;
if (used == 0) {
return _ZERO;
}
final r_used = used - n;
if (r_used <= 0) {
return _neg ? _MINUS_ONE : _ZERO;
}
final digits = _digits;
final r_digits = new Uint32List(r_used + (r_used & 1));
for (var i = n; i < used; i++) {
r_digits[i - n] = digits[i];
}
final r = new _Bigint(_neg, r_used, r_digits);
if (_neg) {
// Round down if any bit was shifted out.
for (var i = 0; i < n; i++) {
if (digits[i] != 0) {
return r._sub(_ONE);
}
}
}
return r;
}
// r_digits[0..r_used-1] = x_digits[0..x_used-1] >> n*_DIGIT_BITS.
// Return r_used.
static int _drShiftDigits(Uint32List x_digits, int x_used, int n,
Uint32List r_digits) {
final r_used = x_used - n;
if (r_used <= 0) {
return 0;
}
assert(r_digits.length >= r_used + (r_used & 1));
for (var i = n; i < x_used; i++) {
r_digits[i - n] = x_digits[i];
}
if (r_used.isOdd) {
r_digits[r_used] = 0;
}
return r_used;
}
// r_digits[0..r_used-1] = x_digits[0..x_used-1] << n.
static void _lsh(Uint32List x_digits, int x_used, int n,
Uint32List r_digits) {
final ds = n ~/ _DIGIT_BITS;
final bs = n % _DIGIT_BITS;
final cbs = _DIGIT_BITS - bs;
final bm = (1 << cbs) - 1;
var c = 0;
var i = x_used;
while (--i >= 0) {
final d = x_digits[i];
r_digits[i + ds + 1] = (d >> cbs) | c;
c = (d & bm) << bs;
}
r_digits[ds] = c;
}
// Return this << n.
_Bigint _lShift(int n) {
final ds = n ~/ _DIGIT_BITS;
final bs = n % _DIGIT_BITS;
if (bs == 0) {
return _dlShift(ds);
}
var r_used = _used + ds + 1;
var r_digits = new Uint32List(r_used + 2 + (r_used & 1)); // +2 for 64-bit.
_lsh(_digits, _used, n, r_digits);
return new _Bigint(_neg, r_used, r_digits);
}
// r_digits[0..r_used-1] = x_digits[0..x_used-1] << n.
// Return r_used.
static int _lShiftDigits(Uint32List x_digits, int x_used, int n,
Uint32List r_digits) {
final ds = n ~/ _DIGIT_BITS;
final bs = n % _DIGIT_BITS;
if (bs == 0) {
return _dlShiftDigits(x_digits, x_used, ds, r_digits);
}
var r_used = x_used + ds + 1;
assert(r_digits.length >= r_used + 2 + (r_used & 1)); // +2 for 64-bit.
_lsh(x_digits, x_used, n, r_digits);
var i = ds;
while (--i >= 0) {
r_digits[i] = 0;
}
if (r_digits[r_used - 1] == 0) {
r_used--; // Clamp result.
} else if (r_used.isOdd) {
r_digits[r_used] = 0;
}
return r_used;
}
// r_digits[0..r_used-1] = x_digits[0..x_used-1] >> n.
static void _rsh(Uint32List x_digits, int x_used, int n,
Uint32List r_digits) {
final ds = n ~/ _DIGIT_BITS;
final bs = n % _DIGIT_BITS;
final cbs = _DIGIT_BITS - bs;
final bm = (1 << bs) - 1;
var c = x_digits[ds] >> bs;
final last = x_used - ds - 1;
for (var i = 0; i < last; i++) {
final d = x_digits[i + ds + 1];
r_digits[i] = ((d & bm) << cbs) | c;
c = d >> bs;
}
r_digits[last] = c;
}
// Return this >> n.
_Bigint _rShift(int n) {
final ds = n ~/ _DIGIT_BITS;
final bs = n % _DIGIT_BITS;
if (bs == 0) {
return _drShift(ds);
}
final used = _used;
final r_used = used - ds;
if (r_used <= 0) {
return _neg ? _MINUS_ONE : _ZERO;
}
final digits = _digits;
final r_digits = new Uint32List(r_used + (r_used & 1));
_rsh(digits, used, n, r_digits);
final r = new _Bigint(_neg, r_used, r_digits);
if (_neg) {
// Round down if any bit was shifted out.
if ((digits[ds] & ((1 << bs) - 1)) != 0) {
return r._sub(_ONE);
}
for (var i = 0; i < ds; i++) {
if (digits[i] != 0) {
return r._sub(_ONE);
}
}
}
return r;
}
// r_digits[0..r_used-1] = x_digits[0..x_used-1] >> n.
// Return r_used.
static int _rShiftDigits(Uint32List x_digits, int x_used, int n,
Uint32List r_digits) {
final ds = n ~/ _DIGIT_BITS;
final bs = n % _DIGIT_BITS;
if (bs == 0) {
return _drShiftDigits(x_digits, x_used, ds, r_digits);
}
var r_used = x_used - ds;
if (r_used <= 0) {
return 0;
}
assert(r_digits.length >= r_used + (r_used & 1));
_rsh(x_digits, x_used, n, r_digits);
if (r_digits[r_used - 1] == 0) {
r_used--; // Clamp result.
} else if (r_used.isOdd) {
r_digits[r_used] = 0;
}
return r_used;
}
// Return 0 if abs(this) == abs(a).
// Return a positive number if abs(this) > abs(a).
// Return a negative number if abs(this) < abs(a).
int _absCompare(_Bigint a) {
var r = _used - a._used;
if (r == 0) {
var i = _used;
var digits = _digits;
var a_digits = a._digits;
while (--i >= 0 && (r = digits[i] - a_digits[i]) == 0);
}
return r;
}
// Return 0 if this == a.
// Return a positive number if this > a.
// Return a negative number if this < a.
int _compare(_Bigint a) {
if (_neg == a._neg) {
var r = _absCompare(a);
return _neg ? -r : r;
}
return _neg ? -1 : 1;
}
// Compare digits[0..used-1] with a_digits[0..a_used-1].
// Return 0 if equal.
// Return a positive number if larger.
// Return a negative number if smaller.
static int _compareDigits(Uint32List digits, int used,
Uint32List a_digits, int a_used) {
var r = used - a_used;
if (r == 0) {
var i = a_used;
while (--i >= 0 && (r = digits[i] - a_digits[i]) == 0);
}
return r;
}
// r_digits[0..used] = digits[0..used-1] + a_digits[0..a_used-1].
// used >= a_used > 0.
// Note: Intrinsics on 64-bit platforms process digit pairs at even indices.
static void _absAdd(Uint32List digits, int used,
Uint32List a_digits, int a_used,
Uint32List r_digits) {
assert(used >= a_used && a_used > 0);
// Verify that digit pairs are accessible for 64-bit processing.
assert(digits.length > ((used - 1) | 1));
assert(a_digits.length > ((a_used - 1) | 1));
assert(r_digits.length > (used | 1));
var c = 0;
for (var i = 0; i < a_used; i++) {
c += digits[i] + a_digits[i];
r_digits[i] = c & _DIGIT_MASK;
c >>= _DIGIT_BITS;
}
for (var i = a_used; i < used; i++) {
c += digits[i];
r_digits[i] = c & _DIGIT_MASK;
c >>= _DIGIT_BITS;
}
r_digits[used] = c;
}
// r_digits[0..used-1] = digits[0..used-1] - a_digits[0..a_used-1].
// used >= a_used > 0.
// Note: Intrinsics on 64-bit platforms process digit pairs at even indices.
static void _absSub(Uint32List digits, int used,
Uint32List a_digits, int a_used,
Uint32List r_digits) {
assert(used >= a_used && a_used > 0);
// Verify that digit pairs are accessible for 64-bit processing.
assert(digits.length > ((used - 1) | 1));
assert(a_digits.length > ((a_used - 1) | 1));
assert(r_digits.length > ((used - 1) | 1));
var c = 0;
for (var i = 0; i < a_used; i++) {
c += digits[i] - a_digits[i];
r_digits[i] = c & _DIGIT_MASK;
c >>= _DIGIT_BITS;
}
for (var i = a_used; i < used; i++) {
c += digits[i];
r_digits[i] = c & _DIGIT_MASK;
c >>= _DIGIT_BITS;
}
}
// Return abs(this) + abs(a) with sign set according to neg.
_Bigint _absAddSetSign(_Bigint a, bool neg) {
var used = _used;
var a_used = a._used;
if (used < a_used) {
return a._absAddSetSign(this, neg);
}
if (used == 0) {
assert(!neg);
return _ZERO;
}
if (a_used == 0) {
return _neg == neg ? this : this._negate();
}
var r_used = used + 1;
var r_digits = new Uint32List(r_used + (r_used & 1));
_absAdd(_digits, used, a._digits, a_used, r_digits);
return new _Bigint(neg, r_used, r_digits);
}
// Return abs(this) - abs(a) with sign set according to neg.
// Requirement: abs(this) >= abs(a).
_Bigint _absSubSetSign(_Bigint a, bool neg) {
assert(_absCompare(a) >= 0);
var used = _used;
if (used == 0) {
assert(!neg);
return _ZERO;
}
var a_used = a._used;
if (a_used == 0) {
return _neg == neg ? this : this._negate();
}
var r_digits = new Uint32List(used + (used & 1));
_absSub(_digits, used, a._digits, a_used, r_digits);
return new _Bigint(neg, used, r_digits);
}
// Return abs(this) & abs(a) with sign set according to neg.
_Bigint _absAndSetSign(_Bigint a, bool neg) {
var r_used = (_used < a._used) ? _used : a._used;
var digits = _digits;
var a_digits = a._digits;
var r_digits = new Uint32List(r_used + (r_used & 1));
for (var i = 0; i < r_used; i++) {
r_digits[i] = digits[i] & a_digits[i];
}
return new _Bigint(neg, r_used, r_digits);
}
// Return abs(this) &~ abs(a) with sign set according to neg.
_Bigint _absAndNotSetSign(_Bigint a, bool neg) {
var r_used = _used;
var digits = _digits;
var a_digits = a._digits;
var r_digits = new Uint32List(r_used + (r_used & 1));
var m = (r_used < a._used) ? r_used : a._used;
for (var i = 0; i < m; i++) {
r_digits[i] = digits[i] &~ a_digits[i];
}
for (var i = m; i < r_used; i++) {
r_digits[i] = digits[i];
}
return new _Bigint(neg, r_used, r_digits);
}
// Return abs(this) | abs(a) with sign set according to neg.
_Bigint _absOrSetSign(_Bigint a, bool neg) {
var used = _used;
var a_used = a._used;
var r_used = (used > a_used) ? used : a_used;
var digits = _digits;
var a_digits = a._digits;
var r_digits = new Uint32List(r_used + (r_used & 1));
var l, m;
if (used < a_used) {
l = a;
m = used;
} else {
l = this;
m = a_used;
}
for (var i = 0; i < m; i++) {
r_digits[i] = digits[i] | a_digits[i];
}
var l_digits = l._digits;
for (var i = m; i < r_used; i++) {
r_digits[i] = l_digits[i];
}
return new _Bigint(neg, r_used, r_digits);
}
// Return abs(this) ^ abs(a) with sign set according to neg.
_Bigint _absXorSetSign(_Bigint a, bool neg) {
var used = _used;
var a_used = a._used;
var r_used = (used > a_used) ? used : a_used;
var digits = _digits;
var a_digits = a._digits;
var r_digits = new Uint32List(r_used + (r_used & 1));
var l, m;
if (used < a_used) {
l = a;
m = used;
} else {
l = this;
m = a_used;
}
for (var i = 0; i < m; i++) {
r_digits[i] = digits[i] ^ a_digits[i];
}
var l_digits = l._digits;
for (var i = m; i < r_used; i++) {
r_digits[i] = l_digits[i];
}
return new _Bigint(neg, r_used, r_digits);
}
// Return this & a.
_Bigint _and(_Bigint a) {
if (_neg == a._neg) {
if (_neg) {
// (-this) & (-a) == ~(this-1) & ~(a-1)
// == ~((this-1) | (a-1))
// == -(((this-1) | (a-1)) + 1)
_Bigint t1 = _absSubSetSign(_ONE, true);
_Bigint a1 = a._absSubSetSign(_ONE, true);
// Result cannot be zero if this and a are negative.
return t1._absOrSetSign(a1, true)._absAddSetSign(_ONE, true);
}
return _absAndSetSign(a, false);
}
// _neg != a._neg
var p, n;
if (_neg) {
p = a;
n = this;
} else { // & is symmetric.
p = this;
n = a;
}
// p & (-n) == p & ~(n-1) == p &~ (n-1)
_Bigint n1 = n._absSubSetSign(_ONE, false);
return p._absAndNotSetSign(n1, false);
}
// Return this &~ a.
_Bigint _andNot(_Bigint a) {
if (_neg == a._neg) {
if (_neg) {
// (-this) &~ (-a) == ~(this-1) &~ ~(a-1)
// == ~(this-1) & (a-1)
// == (a-1) &~ (this-1)
_Bigint t1 = _absSubSetSign(_ONE, true);
_Bigint a1 = a._absSubSetSign(_ONE, true);
return a1._absAndNotSetSign(t1, false);
}
return _absAndNotSetSign(a, false);
}
if (_neg) {
// (-this) &~ a == ~(this-1) &~ a
// == ~(this-1) & ~a
// == ~((this-1) | a)
// == -(((this-1) | a) + 1)
_Bigint t1 = _absSubSetSign(_ONE, true);
// Result cannot be zero if this is negative and a is positive.
return t1._absOrSetSign(a, true)._absAddSetSign(_ONE, true);
}
// this &~ (-a) == this &~ ~(a-1) == this & (a-1)
_Bigint a1 = a._absSubSetSign(_ONE, true);
return _absAndSetSign(a1, false);
}
// Return this | a.
_Bigint _or(_Bigint a) {
if (_neg == a._neg) {
if (_neg) {
// (-this) | (-a) == ~(this-1) | ~(a-1)
// == ~((this-1) & (a-1))
// == -(((this-1) & (a-1)) + 1)
_Bigint t1 = _absSubSetSign(_ONE, true);
_Bigint a1 = a._absSubSetSign(_ONE, true);
// Result cannot be zero if this and a are negative.
return t1._absAndSetSign(a1, true)._absAddSetSign(_ONE, true);
}
return _absOrSetSign(a, false);
}
// _neg != a._neg
var p, n;
if (_neg) {
p = a;
n = this;
} else { // | is symmetric.
p = this;
n = a;
}
// p | (-n) == p | ~(n-1) == ~((n-1) &~ p) == -(~((n-1) &~ p) + 1)
_Bigint n1 = n._absSubSetSign(_ONE, true);
// Result cannot be zero if only one of this or a is negative.
return n1._absAndNotSetSign(p, true)._absAddSetSign(_ONE, true);
}
// Return this ^ a.
_Bigint _xor(_Bigint a) {
if (_neg == a._neg) {
if (_neg) {
// (-this) ^ (-a) == ~(this-1) ^ ~(a-1) == (this-1) ^ (a-1)
_Bigint t1 = _absSubSetSign(_ONE, true);
_Bigint a1 = a._absSubSetSign(_ONE, true);
return t1._absXorSetSign(a1, false);
}
return _absXorSetSign(a, false);
}
// _neg != a._neg
var p, n;
if (_neg) {
p = a;
n = this;
} else { // ^ is symmetric.
p = this;
n = a;
}
// p ^ (-n) == p ^ ~(n-1) == ~(p ^ (n-1)) == -((p ^ (n-1)) + 1)
_Bigint n1 = n._absSubSetSign(_ONE, true);
// Result cannot be zero if only one of this or a is negative.
return p._absXorSetSign(n1, true)._absAddSetSign(_ONE, true);
}
// Return ~this.
_Bigint _not() {
if (_neg) {
// ~(-this) == ~(~(this-1)) == this-1
return _absSubSetSign(_ONE, false);
}
// ~this == -this-1 == -(this+1)
// Result cannot be zero if this is positive.
return _absAddSetSign(_ONE, true);
}
// Return this + a.
_Bigint _add(_Bigint a) {
var neg = _neg;
if (neg == a._neg) {
// this + a == this + a
// (-this) + (-a) == -(this + a)
return _absAddSetSign(a, neg);
}
// this + (-a) == this - a == -(this - a)
// (-this) + a == a - this == -(this - a)
if (_absCompare(a) >= 0) {
return _absSubSetSign(a, neg);
}
return a._absSubSetSign(this, !neg);
}
// Return this - a.
_Bigint _sub(_Bigint a) {
var neg = _neg;
if (neg != a._neg) {
// this - (-a) == this + a
// (-this) - a == -(this + a)
return _absAddSetSign(a, neg);
}
// this - a == this - a == -(this - a)
// (-this) - (-a) == a - this == -(this - a)
if (_absCompare(a) >= 0) {
return _absSubSetSign(a, neg);
}
return a._absSubSetSign(this, !neg);
}
// Multiply and accumulate.
// Input:
// x_digits[xi]: multiplier digit x.
// m_digits[i..i+n-1]: multiplicand digits.
// a_digits[j..j+n-1]: accumulator digits.
// Operation:
// a_digits[j..j+n] += x_digits[xi]*m_digits[i..i+n-1].
// return 1.
// Note: Intrinsics on 64-bit platforms process digit pairs at even indices
// and return 2.
static int _mulAdd(Uint32List x_digits, int xi,
Uint32List m_digits, int i,
Uint32List a_digits, int j, int n) {
// Verify that digit pairs are accessible for 64-bit processing.
assert(x_digits.length > (xi | 1));
assert(m_digits.length > ((i + n - 1) | 1));
assert(a_digits.length > ((j + n) | 1));
int x = x_digits[xi];
if (x == 0) {
// No-op if x is 0.
return 1;
}
int c = 0;
int xl = x & _DIGIT2_MASK;
int xh = x >> _DIGIT2_BITS;
while (--n >= 0) {
int l = m_digits[i] & _DIGIT2_MASK;
int h = m_digits[i++] >> _DIGIT2_BITS;
int m = xh*l + h*xl;
l = xl*l + ((m & _DIGIT2_MASK) << _DIGIT2_BITS) + a_digits[j] + c;
c = (l >> _DIGIT_BITS) + (m >> _DIGIT2_BITS) + xh*h;
a_digits[j++] = l & _DIGIT_MASK;
}
while (c != 0) {
int l = a_digits[j] + c;
c = l >> _DIGIT_BITS;
a_digits[j++] = l & _DIGIT_MASK;
}
return 1;
}
// Square and accumulate.
// Input:
// x_digits[i..used-1]: digits of operand being squared.
// a_digits[2*i..i+used-1]: accumulator digits.
// Operation:
// a_digits[2*i..i+used-1] += x_digits[i]*x_digits[i] +
// 2*x_digits[i]*x_digits[i+1..used-1].
// return 1.
// Note: Intrinsics on 64-bit platforms process digit pairs at even indices
// and return 2.
static int _sqrAdd(Uint32List x_digits, int i,
Uint32List a_digits, int used) {
// Verify that digit pairs are accessible for 64-bit processing.
assert(x_digits.length > ((used - 1) | 1));
assert(a_digits.length > ((i + used - 1) | 1));
int x = x_digits[i];
if (x == 0) return 1;
int j = 2*i;
int c = 0;
int xl = x & _DIGIT2_MASK;
int xh = x >> _DIGIT2_BITS;
int m = 2*xh*xl;
int l = xl*xl + ((m & _DIGIT2_MASK) << _DIGIT2_BITS) + a_digits[j];
c = (l >> _DIGIT_BITS) + (m >> _DIGIT2_BITS) + xh*xh;
a_digits[j] = l & _DIGIT_MASK;
x <<= 1;
xl = x & _DIGIT2_MASK;
xh = x >> _DIGIT2_BITS;
int n = used - i - 1;
int k = i + 1;
j++;
while (--n >= 0) {
int l = x_digits[k] & _DIGIT2_MASK;
int h = x_digits[k++] >> _DIGIT2_BITS;
int m = xh*l + h*xl;
l = xl*l + ((m & _DIGIT2_MASK) << _DIGIT2_BITS) + a_digits[j] + c;
c = (l >> _DIGIT_BITS) + (m >> _DIGIT2_BITS) + xh*h;
a_digits[j++] = l & _DIGIT_MASK;
}
c += a_digits[i + used];
if (c >= _DIGIT_BASE) {
a_digits[i + used] = c - _DIGIT_BASE;
a_digits[i + used + 1] = 1;
} else {
a_digits[i + used] = c;
}
return 1;
}
// Return this * a.
_Bigint _mul(_Bigint a) {
// TODO(regis): Use karatsuba multiplication when appropriate.
var used = _used;
var a_used = a._used;
if (used == 0 || a_used == 0) {
return _ZERO;
}
var r_used = used + a_used;
var digits = _digits;
var a_digits = a._digits;
var r_digits = new Uint32List(r_used + (r_used & 1));
var i = 0;
while (i < a_used) {
i += _mulAdd(a_digits, i, digits, 0, r_digits, i, used);
}
return new _Bigint(_neg != a._neg, r_used, r_digits);
}
// r_digits[0..r_used-1] = x_digits[0..x_used-1]*a_digits[0..a_used-1].
// Return r_used = x_used + a_used.
static int _mulDigits(Uint32List x_digits, int x_used,
Uint32List a_digits, int a_used,
Uint32List r_digits) {
var r_used = x_used + a_used;
var i = r_used + (r_used & 1);
assert(r_digits.length >= i);
while (--i >= 0) {
r_digits[i] = 0;
}
i = 0;
while (i < a_used) {
i += _mulAdd(a_digits, i, x_digits, 0, r_digits, i, x_used);
}
return r_used;
}
// Return this^2.
_Bigint _sqr() {
var used = _used;
if (used == 0) {
return _ZERO;
}
var r_used = 2 * used;
var digits = _digits;
var r_digits = new Uint32List(r_used);
// Since r_used is even, no need for a leading zero for 64-bit processing.
var i = 0;
while (i < used - 1) {
i += _sqrAdd(digits, i, r_digits, used);
}
// The last step is already done if digit pairs were processed above.
if (i < used) {
_mulAdd(digits, i, digits, i, r_digits, 2*i, 1);
}
return new _Bigint(false, r_used, r_digits);
}
// r_digits[0..r_used-1] = x_digits[0..x_used-1]*x_digits[0..x_used-1].
// Return r_used = 2*x_used.
static int _sqrDigits(Uint32List x_digits, int x_used, Uint32List r_digits) {
var r_used = 2 * x_used;
assert(r_digits.length >= r_used);
// Since r_used is even, no need for a leading zero for 64-bit processing.
var i = r_used;
while (--i >= 0) {
r_digits[i] = 0;
}
i = 0;
while (i < x_used - 1) {
i += _sqrAdd(x_digits, i, r_digits, x_used);
}
// The last step is already done if digit pairs were processed above.
if (i < x_used) {
_mulAdd(x_digits, i, x_digits, i, r_digits, 2*i, 1);
}
return r_used;
}
// Indices of the arguments of _estQuotientDigit.
// For 64-bit processing by intrinsics on 64-bit platforms, the top digit pair
// of divisor y is provided in the args array, and a 64-bit estimated quotient
// is returned. However, on 32-bit platforms, the low 32-bit digit is ignored
// and only one 32-bit digit is returned as the estimated quotient.
static const int _YT_LO = 0; // Low digit of top digit pair of y, for 64-bit.
static const int _YT = 1; // Top digit of divisor y.
static const int _QD = 2; // Estimated quotient.
static const int _QD_HI = 3; // High digit of estimated quotient, for 64-bit.
// Operation:
// Estimate args[_QD] = digits[i-1..i] ~/ args[_YT]
// return 1
// Note: Intrinsics on 64-bit platforms process a digit pair (i always odd):
// Estimate args[_QD.._QD_HI] = digits[i-3..i] ~/ args[_YT_LO.._YT]
// return 2
static int _estQuotientDigit(Uint32List args, Uint32List digits, int i) {
// Verify that digit pairs are accessible for 64-bit processing.
assert(digits.length >= 4);
if (digits[i] == args[_YT]) {
args[_QD] = _DIGIT_MASK;
} else {
// Chop off one bit, since a Mint cannot hold 2 DIGITs.
var qd = ((digits[i] << (_DIGIT_BITS - 1)) | (digits[i - 1] >> 1))
~/ (args[_YT] >> 1);
if (qd > _DIGIT_MASK) {
args[_QD] = _DIGIT_MASK;
} else {
args[_QD] = qd;
}
}
return 1;
}
// Return trunc(this / a), a != 0.
_Bigint _div(_Bigint a) {
assert(a._used > 0);
if (_used < a._used) {
return _ZERO;
}
_divRem(a);
// Return quotient, i.e.
// _lastQuoRem_digits[_lastRem_used.._lastQuoRem_used-1] with proper sign.
var lastQuo_used = _lastQuoRem_used - _lastRem_used;
var quo_digits = _cloneDigits(_lastQuoRem_digits,
_lastRem_used,
_lastQuoRem_used,
lastQuo_used);
var quo = new _Bigint(false, lastQuo_used, quo_digits);
if ((_neg != a._neg) && (quo._used > 0)) {
quo = quo._negate();
}
return quo;
}
// Return this - a * trunc(this / a), a != 0.
_Bigint _rem(_Bigint a) {
assert(a._used > 0);
if (_used < a._used) {
return this;
}
_divRem(a);
// Return remainder, i.e.
// denormalized _lastQuoRem_digits[0.._lastRem_used-1] with proper sign.
var rem_digits = _cloneDigits(_lastQuoRem_digits,
0,
_lastRem_used,
_lastRem_used);
var rem = new _Bigint(false, _lastRem_used, rem_digits);
if (_lastRem_nsh > 0) {
rem = rem._rShift(_lastRem_nsh); // Denormalize remainder.
}
if (_neg && (rem._used > 0)) {
rem = rem._negate();
}
return rem;
}
// Cache concatenated positive quotient and normalized positive remainder.
void _divRem(_Bigint a) {
// Check if result is already cached (identical on Bigint is too expensive).
if ((this._used == _lastDividend_used) &&
(a._used == _lastDivisor_used) &&
identical(this._digits, _lastDividend_digits) &&
identical(a._digits, _lastDivisor_digits)) {
return;
}
var nsh = _DIGIT_BITS - _nbits(a._digits[a._used - 1]);
// For 64-bit processing, make sure y has an even number of digits.
if (a._used.isOdd) {
nsh += _DIGIT_BITS;
}
// Concatenated positive quotient and normalized positive remainder.
var r_digits;
var r_used;
// Normalized positive divisor.
var y_digits;
var y_used;
if (nsh > 0) {
y_digits = new Uint32List(a._used + 5); // +5 for norm. and 64-bit.
y_used = _lShiftDigits(a._digits, a._used, nsh, y_digits);
r_digits = new Uint32List(_used + 5); // +5 for normalization and 64-bit.
r_used = _lShiftDigits(_digits, _used, nsh, r_digits);
} else {
y_digits = a._digits;
y_used = a._used;
r_digits = _cloneDigits(_digits, 0, _used, _used + 2);
r_used = _used;
}
Uint32List yt_qd = new Uint32List(4);
yt_qd[_YT_LO] = y_digits[y_used - 2];
yt_qd[_YT] = y_digits[y_used - 1];
// For 64-bit processing, make sure y_used, i, and j are even.
assert(y_used.isEven);
var i = r_used + (r_used & 1);
var j = i - y_used;
// t_digits is a temporary array of i digits.
var t_digits = new Uint32List(i);
var t_used = _dlShiftDigits(y_digits, y_used, j, t_digits);
// Explicit first division step in case normalized dividend is larger or
// equal to shifted normalized divisor.
if (_compareDigits(r_digits, r_used, t_digits, t_used) >= 0) {
assert(i == r_used);
r_digits[r_used++] = 1; // Quotient = 1.
r_digits[r_used] = 0; // Leading zero.
// Subtract divisor from remainder.
_absSub(r_digits, r_used, t_digits, t_used, r_digits);
}
// Negate y so we can later use _mulAdd instead of non-existent _mulSub.
var ny_digits = new Uint32List(y_used + 2);
ny_digits[y_used] = 1;
_absSub(ny_digits, y_used + 1, y_digits, y_used, ny_digits);
// ny_digits is read-only and has y_used digits (possibly including several
// leading zeros) plus a leading zero for 64-bit processing.
// r_digits is modified during iteration.
// r_digits[0..y_used-1] is the current remainder.
// r_digits[y_used..r_used-1] is the current quotient.
--i;
while (j > 0) {
var d0 = _estQuotientDigit(yt_qd, r_digits, i);
j -= d0;
var d1 = _mulAdd(yt_qd, _QD, ny_digits, 0, r_digits, j, y_used);
// _estQuotientDigit and _mulAdd must agree on the number of digits to
// process.
assert(d0 == d1);
if (d0 == 1) {
if (r_digits[i] < yt_qd[_QD]) {
var t_used = _dlShiftDigits(ny_digits, y_used, j, t_digits);
_absSub(r_digits, r_used, t_digits, t_used, r_digits);
while (r_digits[i] < --yt_qd[_QD]) {
_absSub(r_digits, r_used, t_digits, t_used, r_digits);
}
}
} else {
assert(d0 == 2);
assert(r_digits[i] <= yt_qd[_QD_HI]);
if ((r_digits[i] < yt_qd[_QD_HI]) || (r_digits[i-1] < yt_qd[_QD])) {
var t_used = _dlShiftDigits(ny_digits, y_used, j, t_digits);
_absSub(r_digits, r_used, t_digits, t_used, r_digits);
if (yt_qd[_QD] == 0) {
--yt_qd[_QD_HI];
}
--yt_qd[_QD];
assert(r_digits[i] <= yt_qd[_QD_HI]);
while ((r_digits[i] < yt_qd[_QD_HI]) ||
(r_digits[i-1] < yt_qd[_QD])) {
_absSub(r_digits, r_used, t_digits, t_used, r_digits);
if (yt_qd[_QD] == 0) {
--yt_qd[_QD_HI];
}
--yt_qd[_QD];
assert(r_digits[i] <= yt_qd[_QD_HI]);
}
}
}
i -= d0;
}
// Cache result.
_lastDividend_digits = _digits;
_lastDividend_used = _used;
_lastDivisor_digits = a._digits;
_lastDivisor_used = a._used;
_lastQuoRem_digits = r_digits;
_lastQuoRem_used = r_used;
_lastRem_used = y_used;
_lastRem_nsh = nsh;
}
// Customized version of _rem() minimizing allocations for use in reduction.
// Input:
// x_digits[0..x_used-1]: positive dividend.
// y_digits[0..y_used-1]: normalized positive divisor.
// ny_digits[0..y_used-1]: negated y_digits.
// nsh: normalization shift amount.
// yt_qd: top y digit(s) and place holder for estimated quotient digit(s).
// t_digits: temp array of 2*y_used digits.
// r_digits: result digits array large enough to temporarily hold
// concatenated quotient and normalized remainder.
// Output:
// r_digits[0..r_used-1]: positive remainder.
// Returns r_used.
static int _remDigits(Uint32List x_digits, int x_used,
Uint32List y_digits, int y_used, Uint32List ny_digits,
int nsh,
Uint32List yt_qd,
Uint32List t_digits,
Uint32List r_digits) {
// Initialize r_digits to normalized positive dividend.
var r_used = _lShiftDigits(x_digits, x_used, nsh, r_digits);
// For 64-bit processing, make sure y_used, i, and j are even.
assert(y_used.isEven);
var i = r_used + (r_used & 1);
var j = i - y_used;
var t_used = _dlShiftDigits(y_digits, y_used, j, t_digits);
// Explicit first division step in case normalized dividend is larger or
// equal to shifted normalized divisor.
if (_compareDigits(r_digits, r_used, t_digits, t_used) >= 0) {
assert(i == r_used);
r_digits[r_used++] = 1; // Quotient = 1.
r_digits[r_used] = 0; // Leading zero.
// Subtract divisor from remainder.
_absSub(r_digits, r_used, t_digits, t_used, r_digits);
}
// Negated y_digits passed in ny_digits allow the use of _mulAdd instead of
// unimplemented _mulSub.
// ny_digits is read-only and has y_used digits (possibly including several
// leading zeros) plus a leading zero for 64-bit processing.
// r_digits is modified during iteration.
// r_digits[0..y_used-1] is the current remainder.
// r_digits[y_used..r_used-1] is the current quotient.
--i;
while (j > 0) {
var d0 = _estQuotientDigit(yt_qd, r_digits, i);
j -= d0;
var d1 = _mulAdd(yt_qd, _QD, ny_digits, 0, r_digits, j, y_used);
// _estQuotientDigit and _mulAdd must agree on the number of digits to
// process.
assert(d0 == d1);
if (d0 == 1) {
if (r_digits[i] < yt_qd[_QD]) {
var t_used = _dlShiftDigits(ny_digits, y_used, j, t_digits);
_absSub(r_digits, r_used, t_digits, t_used, r_digits);
while (r_digits[i] < --yt_qd[_QD]) {
_absSub(r_digits, r_used, t_digits, t_used, r_digits);
}
}
} else {
assert(d0 == 2);
assert(r_digits[i] <= yt_qd[_QD_HI]);
if ((r_digits[i] < yt_qd[_QD_HI]) || (r_digits[i-1] < yt_qd[_QD])) {
var t_used = _dlShiftDigits(ny_digits, y_used, j, t_digits);
_absSub(r_digits, r_used, t_digits, t_used, r_digits);
if (yt_qd[_QD] == 0) {
--yt_qd[_QD_HI];
}
--yt_qd[_QD];
assert(r_digits[i] <= yt_qd[_QD_HI]);
while ((r_digits[i] < yt_qd[_QD_HI]) ||
(r_digits[i-1] < yt_qd[_QD])) {
_absSub(r_digits, r_used, t_digits, t_used, r_digits);
if (yt_qd[_QD] == 0) {
--yt_qd[_QD_HI];
}
--yt_qd[_QD];
assert(r_digits[i] <= yt_qd[_QD_HI]);
}
}
}
i -= d0;
}
// Return remainder, i.e. denormalized r_digits[0..y_used-1].
r_used = y_used;
if (nsh > 0) {
// Denormalize remainder.
r_used = _rShiftDigits(r_digits, r_used, nsh, r_digits);
}
return r_used;
}
int get _identityHashCode {
return this;
}
int operator ~() {
return _not()._toValidInt();
}
int get bitLength {
if (_used == 0) return 0;
if (_neg) return (~this).bitLength;
return _DIGIT_BITS*(_used - 1) + _nbits(_digits[_used - 1]);
}
// This method must support smi._toBigint()._shrFromInt(int).
int _shrFromInt(int other) {
if (_used == 0) return other; // Shift amount is zero.
if (_neg) throw new RangeError(this);
assert(_DIGIT_BITS == 32); // Otherwise this code needs to be revised.
var shift;
if ((_used > 2) || ((_used == 2) && (_digits[1] > 0x10000000))) {
if (other < 0) {
return -1;
} else {
return 0;
}
} else {
shift = ((_used == 2) ? (_digits[1] << _DIGIT_BITS) : 0) + _digits[0];
}
return other._toBigint()._rShift(shift)._toValidInt();
}
// This method must support smi._toBigint()._shlFromInt(int).
// An out of memory exception is thrown if the result cannot be allocated.
int _shlFromInt(int other) {
if (_used == 0) return other; // Shift amount is zero.
if (_neg) throw new RangeError(this);
assert(_DIGIT_BITS == 32); // Otherwise this code needs to be revised.
var shift;
if (_used > 2 || (_used == 2 && _digits[1] > 0x10000000)) {
if (other == 0) return 0; // Shifted value is zero.
throw new OutOfMemoryError();
} else {
shift = ((_used == 2) ? (_digits[1] << _DIGIT_BITS) : 0) + _digits[0];
}
return other._toBigint()._lShift(shift)._toValidInt();
}
// Overriden operators and methods.
// The following operators override operators of _IntegerImplementation for
// efficiency, but are not necessary for correctness. They shortcut native
// calls that would return null because the receiver is _Bigint.
num operator +(num other) {
return other._toBigintOrDouble()._addFromInteger(this);
}
num operator -(num other) {
return other._toBigintOrDouble()._subFromInteger(this);
}
num operator *(num other) {
return other._toBigintOrDouble()._mulFromInteger(this);
}
num operator ~/(num other) {
if ((other is int) && (other == 0)) {
throw const IntegerDivisionByZeroException();
}
return other._toBigintOrDouble()._truncDivFromInteger(this);
}
num operator %(num other) {
if ((other is int) && (other == 0)) {
throw const IntegerDivisionByZeroException();
}
return other._toBigintOrDouble()._moduloFromInteger(this);
}
int operator &(int other) {
return other._toBigintOrDouble()._bitAndFromInteger(this);
}
int operator |(int other) {
return other._toBigintOrDouble()._bitOrFromInteger(this);
}
int operator ^(int other) {
return other._toBigintOrDouble()._bitXorFromInteger(this);
}
int operator >>(int other) {
return other._toBigintOrDouble()._shrFromInt(this);
}
int operator <<(int other) {
return other._toBigintOrDouble()._shlFromInt(this);
}
// End of operator shortcuts.
int operator -() {
return _negate()._toValidInt();
}
int get sign {
return (_used == 0) ? 0 : _neg ? -1 : 1;
}
bool get isEven => _used == 0 || (_digits[0] & 1) == 0;
bool get isNegative => _neg;
String _toPow2String(int radix) {
if (_used == 0) return "0";
assert(radix & (radix - 1) == 0);
final bitsPerChar = radix.bitLength - 1;
final firstcx = _neg ? 1 : 0; // Index of first char in str after the sign.
final lastdx = _used - 1; // Index of last digit in bigint.
final bitLength = lastdx*_DIGIT_BITS + _nbits(_digits[lastdx]);
// Index of char in str. Initialize with str length.
var cx = firstcx + (bitLength + bitsPerChar - 1) ~/ bitsPerChar;
_OneByteString str = _OneByteString._allocate(cx);
str._setAt(0, 0x2d); // '-'. Is overwritten if not negative.
final mask = radix - 1;
var dx = 0; // Digit index in bigint.
var bx = 0; // Bit index in bigint digit.
do {
var ch;
if (bx > (_DIGIT_BITS - bitsPerChar)) {
ch = _digits[dx++] >> bx;
bx += bitsPerChar - _DIGIT_BITS;
if (dx <= lastdx) {
ch |= (_digits[dx] & ((1 << bx) - 1)) << (bitsPerChar - bx);
}
} else {
ch = (_digits[dx] >> bx) & mask;
bx += bitsPerChar;
if (bx >= _DIGIT_BITS) {
bx -= _DIGIT_BITS;
dx++;
}
}
str._setAt(--cx, _IntegerImplementation._digits.codeUnitAt(ch));
} while (cx > firstcx);
return str;
}
_leftShiftWithMask32(int count, int mask) {
if (_used == 0) return 0;
if (count is! _Smi) {
_shlFromInt(count); // Throws out of memory exception.
}
assert(_DIGIT_BITS == 32); // Otherwise this code needs to be revised.
if (count > 31) return 0;
return (_digits[0] << count) & mask;
}
int _bitAndFromInteger(int other) {
return other._toBigint()._and(this)._toValidInt();
}
int _bitOrFromInteger(int other) {
return other._toBigint()._or(this)._toValidInt();
}
int _bitXorFromInteger(int other) {
return other._toBigint()._xor(this)._toValidInt();
}
int _addFromInteger(int other) {
return other._toBigint()._add(this)._toValidInt();
}
int _subFromInteger(int other) {
return other._toBigint()._sub(this)._toValidInt();
}
int _mulFromInteger(int other) {
return other._toBigint()._mul(this)._toValidInt();
}
int _truncDivFromInteger(int other) {
return other._toBigint()._div(this)._toValidInt();
}
int _moduloFromInteger(int other) {
_Bigint result = other._toBigint()._rem(this);
if (result._neg) {
if (_neg) {
result = result._sub(this);
} else {
result = result._add(this);
}
}
return result._toValidInt();
}
int _remainderFromInteger(int other) {
return other._toBigint()._rem(this)._toValidInt();
}
bool _greaterThanFromInteger(int other) {
return other._toBigint()._compare(this) > 0;
}
bool _equalToInteger(int other) {
return other._toBigint()._compare(this) == 0;
}
// Returns pow(this, e) % m, with e >= 0, m > 0.
int modPow(int e, int m) {
if (e is! int) throw new ArgumentError(e);
if (m is! int) throw new ArgumentError(m);
if (e < 0) throw new RangeError(e);
if (m <= 0) throw new RangeError(m);
if (e == 0) return 1;
m = m._toBigint();
final m_used = m._used;
final m_used2p4 = 2*m_used + 4;
final e_bitlen = e.bitLength;
if (e_bitlen <= 0) return 1;
final bool cannotUseMontgomery = m.isEven || _abs() >= m;
if (cannotUseMontgomery || e_bitlen < 64) {
_Reduction z = (cannotUseMontgomery || e_bitlen < 8) ?
new _Classic(m) : new _Montgomery(m);
// TODO(regis): Should we use Barrett reduction for an even modulus and a
// large exponent?
var r_digits = new Uint32List(m_used2p4);
var r2_digits = new Uint32List(m_used2p4);
var g_digits = new Uint32List(m_used + (m_used & 1));
var g_used = z._convert(this, g_digits);
// Initialize r with g.
var j = g_used + (g_used & 1); // Copy leading zero if any.
while (--j >= 0) {
r_digits[j] = g_digits[j];
}
var r_used = g_used;
var r2_used;
var i = e_bitlen - 1;
while (--i >= 0) {
r2_used = z._sqr(r_digits, r_used, r2_digits);
if ((e & (1 << i)) != 0) {
r_used = z._mul(r2_digits, r2_used, g_digits, g_used, r_digits);
} else {
var t_digits = r_digits;
var t_used = r_used;
r_digits = r2_digits;
r_used = r2_used;
r2_digits = t_digits;
r2_used = t_used;
}
}
return z._revert(r_digits, r_used)._toValidInt();
}
e = e._toBigint();
var k;
if (e_bitlen < 18) k = 1;
else if (e_bitlen < 48) k = 3;
else if (e_bitlen < 144) k = 4;
else if (e_bitlen < 768) k = 5;
else k = 6;
_Reduction z = new _Montgomery(m);
var n = 3;
final k1 = k - 1;
final km = (1 << k) - 1;
List g_digits = new List(km + 1);
List g_used = new List(km + 1);
g_digits[1] = new Uint32List(m_used + (m_used & 1));
g_used[1] = z._convert(this, g_digits[1]);
if (k > 1) {
var g2_digits = new Uint32List(m_used2p4);
var g2_used = z._sqr(g_digits[1], g_used[1], g2_digits);
while (n <= km) {
g_digits[n] = new Uint32List(m_used2p4);
g_used[n] = z._mul(g2_digits, g2_used,
g_digits[n - 2], g_used[n - 2],
g_digits[n]);
n += 2;
}
}
var w;
var is1 = true;
var r_digits = _ONE._digits;
var r_used = _ONE._used;
var r2_digits = new Uint32List(m_used2p4);
var r2_used;
var e_digits = e._digits;
var j = e._used - 1;
var i = _nbits(e_digits[j]) - 1;
while (j >= 0) {
if (i >= k1) {
w = (e_digits[j] >> (i - k1)) & km;
} else {
w = (e_digits[j] & ((1 << (i + 1)) - 1)) << (k1 - i);
if (j > 0) {
w |= e_digits[j - 1] >> (_DIGIT_BITS + i - k1);
}
}
n = k;
while ((w & 1) == 0) {
w >>= 1;
--n;
}
if ((i -= n) < 0) {
i += _DIGIT_BITS;
--j;
}
if (is1) { // r == 1, don't bother squaring or multiplying it.
r_digits = new Uint32List(m_used2p4);
r_used = g_used[w];
var gw_digits = g_digits[w];
var ri = r_used + (r_used & 1); // Copy leading zero if any.
while (--ri >= 0) {
r_digits[ri] = gw_digits[ri];
}
is1 = false;
}
else {
while (n > 1) {
r2_used = z._sqr(r_digits, r_used, r2_digits);
r_used = z._sqr(r2_digits, r2_used, r_digits);
n -= 2;
}
if (n > 0) {
r2_used = z._sqr(r_digits, r_used, r2_digits);
} else {
var t_digits = r_digits;
var t_used = r_used;
r_digits = r2_digits;
r_used = r2_used;
r2_digits = t_digits;
r2_used = t_used;
}
r_used = z._mul(r2_digits, r2_used, g_digits[w], g_used[w], r_digits);
}
while (j >= 0 && (e_digits[j] & (1 << i)) == 0) {
r2_used = z._sqr(r_digits, r_used, r2_digits);
var t_digits = r_digits;
var t_used = r_used;
r_digits = r2_digits;
r_used = r2_used;
r2_digits = t_digits;
r2_used = t_used;
if (--i < 0) {
i = _DIGIT_BITS - 1;
--j;
}
}
}
assert(!is1);
return z._revert(r_digits, r_used)._toValidInt();
}
}
// Interface for modular reduction.
class _Reduction {
// Return the number of digits used by r_digits.
int _convert(_Bigint x, Uint32List r_digits);
int _mul(Uint32List x_digits, int x_used,
Uint32List y_digits, int y_used, Uint32List r_digits);
int _sqr(Uint32List x_digits, int x_used, Uint32List r_digits);
// Return x reverted to _Bigint.
_Bigint _revert(Uint32List x_digits, int x_used);
}
// Montgomery reduction on _Bigint.
class _Montgomery implements _Reduction {
_Bigint _m; // Modulus.
int _mused2p2;
Uint32List _args;
int _digits_per_step; // Number of digits processed in one step. 1 or 2.
static const int _X = 0; // Index of x.
static const int _X_HI = 1; // Index of high 32-bits of x (64-bit only).
static const int _RHO = 2; // Index of rho.
static const int _RHO_HI = 3; // Index of high 32-bits of rho (64-bit only).
static const int _MU = 4; // Index of mu.
static const int _MU_HI = 5; // Index of high 32-bits of mu (64-bit only).
_Montgomery(m) {
_m = m._toBigint();
_mused2p2 = 2*_m._used + 2;
_args = new Uint32List(6);
// Determine if we can process digit pairs by calling an intrinsic.
_digits_per_step = _mulMod(_args, _args, 0);
_args[_X] = _m._digits[0];
if (_digits_per_step == 1) {
_invDigit(_args);
} else {
assert(_digits_per_step == 2);
_args[_X_HI] = _m._digits[1];
_invDigitPair(_args);
}
}
// Calculates -1/x % _DIGIT_BASE, x is 32-bit digit.
// xy == 1 (mod m)
// xy = 1+km
// xy(2-xy) = (1+km)(1-km)
// x(y(2-xy)) = 1-k^2 m^2
// x(y(2-xy)) == 1 (mod m^2)
// if y is 1/x mod m, then y(2-xy) is 1/x mod m^2
// Should reduce x and y(2-xy) by m^2 at each step to keep size bounded.
//
// Operation:
// args[_RHO] = 1/args[_X] mod _DIGIT_BASE.
static void _invDigit(Uint32List args) {
var x = args[_X];
var y = x & 3; // y == 1/x mod 2^2
y = (y*(2 - (x & 0xf)*y)) & 0xf; // y == 1/x mod 2^4
y = (y*(2 - (x & 0xff)*y)) & 0xff; // y == 1/x mod 2^8
y = (y*(2 - (((x & 0xffff)*y) & 0xffff))) & 0xffff; // y == 1/x mod 2^16
// Last step - calculate inverse mod _DIGIT_BASE directly;
// Assumes 16 < _DIGIT_BITS <= 32 and assumes ability to handle 48-bit ints.
y = (y*(2 - x*y % _Bigint._DIGIT_BASE)) % _Bigint._DIGIT_BASE;
// y == 1/x mod _DIGIT_BASE
y = -y; // We really want the negative inverse.
args[_RHO] = y & _Bigint._DIGIT_MASK;
}
// Calculates -1/x % _DIGIT_BASE^2, x is a pair of 32-bit digits.
// Operation:
// args[_RHO.._RHO_HI] = 1/args[_X.._X_HI] mod _DIGIT_BASE^2.
static void _invDigitPair(Uint32List args) {
var xl = args[_X]; // Lower 32-bit digit of x.
var y = xl & 3; // y == 1/x mod 2^2
y = (y*(2 - (xl & 0xf)*y)) & 0xf; // y == 1/x mod 2^4
y = (y*(2 - (xl & 0xff)*y)) & 0xff; // y == 1/x mod 2^8
y = (y*(2 - (((xl & 0xffff)*y) & 0xffff))) & 0xffff; // y == 1/x mod 2^16
y = (y*(2 - ((xl*y) & 0xffffffff))) & 0xffffffff; // y == 1/x mod 2^32
var x = (args[_X_HI] << _Bigint._DIGIT_BITS) | xl;
y = (y*(2 - ((x*y) & 0xffffffffffffffff))) & 0xffffffffffffffff;
// y == 1/x mod _DIGIT_BASE^2
y = -y; // We really want the negative inverse.
args[_RHO] = y & _Bigint._DIGIT_MASK;
args[_RHO_HI] = (y >> _Bigint._DIGIT_BITS) & _Bigint._DIGIT_MASK;
}
// Operation:
// args[_MU] = args[_RHO]*digits[i] mod _DIGIT_BASE.
// return 1.
// Note: Intrinsics on 64-bit platforms process digit pairs at even indices:
// args[_MU.._MU_HI] = args[_RHO.._RHO_HI]*digits[i..i+1] mod _DIGIT_BASE^2.
// return 2.
static int _mulMod(Uint32List args, Uint32List digits, int i) {
// Verify that digit pairs are accessible for 64-bit processing.
assert(digits.length > (i | 1));
const int MU_MASK = (1 << (_Bigint._DIGIT_BITS - _Bigint._DIGIT2_BITS)) - 1;
var rhol = args[_RHO] & _Bigint._DIGIT2_MASK;
var rhoh = args[_RHO] >> _Bigint._DIGIT2_BITS;
var dh = digits[i] >> _Bigint._DIGIT2_BITS;
var dl = digits[i] & _Bigint._DIGIT2_MASK;
args[_MU] =
(dl*rhol + (((dl*rhoh + dh*rhol) & MU_MASK) << _Bigint._DIGIT2_BITS))
& _Bigint._DIGIT_MASK;
return 1;
}
// r = x*R mod _m.
// Return r_used.
int _convert(_Bigint x, Uint32List r_digits) {
// Montgomery reduction only works if abs(x) < _m.
assert(x._abs() < _m);
var r = x._abs()._dlShift(_m._used)._rem(_m);
if (x._neg && !r._neg && r._used > 0) {
r = _m._sub(r);
}
var used = r._used;
var digits = r._digits;
var i = used + (used & 1);
while (--i >= 0) {
r_digits[i] = digits[i];
}
return used;
}
_Bigint _revert(Uint32List x_digits, int x_used) {
var r_digits = new Uint32List(_mused2p2);
var i = x_used + (x_used & 1);
while (--i >= 0) {
r_digits[i] = x_digits[i];
}
var r_used = _reduce(r_digits, x_used);
return new _Bigint(false, r_used, r_digits);
}
// x = x/R mod _m.
// Return x_used.
int _reduce(Uint32List x_digits, int x_used) {
while (x_used < _mused2p2) { // Pad x so _mulAdd has enough room later.
x_digits[x_used++] = 0;
}
var m_used = _m._used;
var m_digits = _m._digits;
var i = 0;
while (i < m_used) {
var d = _mulMod(_args, x_digits, i);
assert(d == _digits_per_step);
d = _Bigint._mulAdd(_args, _MU, m_digits, 0, x_digits, i, m_used);
assert(d == _digits_per_step);
i += d;
}
// Clamp x.
while (x_used > 0 && x_digits[x_used - 1] == 0) {
--x_used;
}
// Shift right by m_used digits or, if processing pairs, by i (even) digits.
x_used = _Bigint._drShiftDigits(x_digits, x_used, i, x_digits);
if (_Bigint._compareDigits(x_digits, x_used, m_digits, m_used) >= 0) {
_Bigint._absSub(x_digits, x_used, m_digits, m_used, x_digits);
}
// Clamp x.
while (x_used > 0 && x_digits[x_used - 1] == 0) {
--x_used;
}
return x_used;
}
int _sqr(Uint32List x_digits, int x_used, Uint32List r_digits) {
var r_used = _Bigint._sqrDigits(x_digits, x_used, r_digits);
return _reduce(r_digits, r_used);
}
int _mul(Uint32List x_digits, int x_used,
Uint32List y_digits, int y_used,
Uint32List r_digits) {
var r_used = _Bigint._mulDigits(x_digits, x_used,
y_digits, y_used,
r_digits);
return _reduce(r_digits, r_used);
}
}
// Modular reduction using "classic" algorithm.
class _Classic implements _Reduction {
_Bigint _m; // Modulus.
_Bigint _norm_m; // Normalized _m.
Uint32List _neg_norm_m_digits; // Negated _norm_m digits.
int _m_nsh; // Normalization shift amount.
Uint32List _mt_qd; // Top _norm_m digit(s) and place holder for
// estimated quotient digit(s).
Uint32List _t_digits; // Temporary digits used during reduction.
_Classic(int m) {
_m = m._toBigint();
// Preprocess arguments to _remDigits.
var nsh = _Bigint._DIGIT_BITS - _Bigint._nbits(_m._digits[_m._used - 1]);
// For 64-bit processing, make sure _norm_m_digits has an even number of
// digits.
if (_m._used.isOdd) {
nsh += _Bigint._DIGIT_BITS;
}
_m_nsh = nsh;
_norm_m = _m._lShift(nsh);
var nm_used = _norm_m._used;
assert(nm_used.isEven);
_mt_qd = new Uint32List(4);
_mt_qd[_Bigint._YT_LO] = _norm_m._digits[nm_used - 2];
_mt_qd[_Bigint._YT] = _norm_m._digits[nm_used - 1];
// Negate _norm_m so we can use _mulAdd instead of unimplemented _mulSub.
var neg_norm_m = _Bigint._ONE._dlShift(nm_used)._sub(_norm_m);
if (neg_norm_m._used < nm_used) {
_neg_norm_m_digits =
_Bigint._cloneDigits(neg_norm_m._digits, 0, nm_used, nm_used);
} else {
_neg_norm_m_digits = neg_norm_m._digits;
}
// _neg_norm_m_digits is read-only and has nm_used digits (possibly
// including several leading zeros) plus a leading zero for 64-bit
// processing.
_t_digits = new Uint32List(2*nm_used);
}
int _convert(_Bigint x, Uint32List r_digits) {
var digits;
var used;
if (x._neg || x._compare(_m) >= 0) {
var r = x._rem(_m);
if (x._neg && !r._neg && r._used > 0) {
r = _m._sub(r);
}
assert(!r._neg);
used = r._used;
digits = r._digits;
} else {
used = x._used;
digits = x._digits;
}
var i = used + (used & 1); // Copy leading zero if any.
while (--i >= 0) {
r_digits[i] = digits[i];
}
return used;
}
_Bigint _revert(Uint32List x_digits, int x_used) {
return new _Bigint(false, x_used, x_digits);
}
int _reduce(Uint32List x_digits, int x_used) {
if (x_used < _m._used) {
return x_used;
}
// The function _remDigits(...) is optimized for reduction and equivalent to
// calling _convert(_revert(x_digits, x_used)._rem(_m), x_digits);
return _Bigint._remDigits(x_digits, x_used,
_norm_m._digits, _norm_m._used,
_neg_norm_m_digits,
_m_nsh,
_mt_qd,
_t_digits,
x_digits);
}
int _sqr(Uint32List x_digits, int x_used, Uint32List r_digits) {
var r_used = _Bigint._sqrDigits(x_digits, x_used, r_digits);
return _reduce(r_digits, r_used);
}
int _mul(Uint32List x_digits, int x_used,
Uint32List y_digits, int y_used,
Uint32List r_digits) {
var r_used = _Bigint._mulDigits(x_digits, x_used,
y_digits, y_used,
r_digits);
return _reduce(r_digits, r_used);
}
}