1991-05-05 17:09:44 -03:00
|
|
|
|
|
|
|
/* Long (arbitrary precision) integer object implementation */
|
|
|
|
|
1991-05-14 09:06:49 -03:00
|
|
|
/* XXX The functional organization of this file is terrible */
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
#include "Python.h"
|
1991-05-05 17:09:44 -03:00
|
|
|
#include "longintrepr.h"
|
1997-05-02 00:12:38 -03:00
|
|
|
|
1994-08-29 09:47:19 -03:00
|
|
|
#include <ctype.h>
|
1991-05-05 17:09:44 -03:00
|
|
|
|
2002-08-11 23:31:19 -03:00
|
|
|
/* For long multiplication, use the O(N**2) school algorithm unless
|
|
|
|
* both operands contain more than KARATSUBA_CUTOFF digits (this
|
|
|
|
* being an internal Python long digit, in base BASE).
|
|
|
|
*/
|
2004-08-29 19:16:50 -03:00
|
|
|
#define KARATSUBA_CUTOFF 70
|
|
|
|
#define KARATSUBA_SQUARE_CUTOFF (2 * KARATSUBA_CUTOFF)
|
2002-08-11 23:31:19 -03:00
|
|
|
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
/* For exponentiation, use the binary left-to-right algorithm
|
|
|
|
* unless the exponent contains more than FIVEARY_CUTOFF digits.
|
|
|
|
* In that case, do 5 bits at a time. The potential drawback is that
|
|
|
|
* a table of 2**5 intermediate results is computed.
|
|
|
|
*/
|
|
|
|
#define FIVEARY_CUTOFF 8
|
|
|
|
|
1992-01-19 12:31:05 -04:00
|
|
|
#define ABS(x) ((x) < 0 ? -(x) : (x))
|
|
|
|
|
2002-08-11 23:31:19 -03:00
|
|
|
#undef MIN
|
|
|
|
#undef MAX
|
|
|
|
#define MAX(x, y) ((x) < (y) ? (y) : (x))
|
|
|
|
#define MIN(x, y) ((x) > (y) ? (y) : (x))
|
|
|
|
|
1992-01-19 12:31:05 -04:00
|
|
|
/* Forward */
|
2000-07-07 12:53:28 -03:00
|
|
|
static PyLongObject *long_normalize(PyLongObject *);
|
|
|
|
static PyLongObject *mul1(PyLongObject *, wdigit);
|
|
|
|
static PyLongObject *muladd1(PyLongObject *, wdigit, wdigit);
|
2001-07-14 09:23:19 -03:00
|
|
|
static PyLongObject *divrem1(PyLongObject *, digit, digit *);
|
2000-07-07 12:53:28 -03:00
|
|
|
static PyObject *long_format(PyObject *aa, int base, int addL);
|
1992-01-19 12:31:05 -04:00
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
#define SIGCHECK(PyTryBlock) \
|
2002-09-03 17:10:45 -03:00
|
|
|
if (--_Py_Ticker < 0) { \
|
|
|
|
_Py_Ticker = _Py_CheckInterval; \
|
1997-05-02 00:12:38 -03:00
|
|
|
if (PyErr_CheckSignals()) { PyTryBlock; } \
|
1991-05-14 09:06:49 -03:00
|
|
|
}
|
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
/* Normalize (remove leading zeros from) a long int object.
|
|
|
|
Doesn't attempt to free the storage--in most cases, due to the nature
|
|
|
|
of the algorithms used, this could save at most be one word anyway. */
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyLongObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
long_normalize(register PyLongObject *v)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
1992-01-14 14:36:43 -04:00
|
|
|
int j = ABS(v->ob_size);
|
1991-05-05 17:09:44 -03:00
|
|
|
register int i = j;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
while (i > 0 && v->ob_digit[i-1] == 0)
|
|
|
|
--i;
|
|
|
|
if (i != j)
|
1992-01-14 14:36:43 -04:00
|
|
|
v->ob_size = (v->ob_size < 0) ? -(i) : i;
|
1991-05-05 17:09:44 -03:00
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate a new long int object with size digits.
|
|
|
|
Return NULL and set exception if we run out of memory. */
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
PyLongObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
_PyLong_New(int size)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
1997-05-02 00:12:38 -03:00
|
|
|
return PyObject_NEW_VAR(PyLongObject, &PyLong_Type, size);
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
|
2001-09-10 17:52:51 -03:00
|
|
|
PyObject *
|
|
|
|
_PyLong_Copy(PyLongObject *src)
|
|
|
|
{
|
|
|
|
PyLongObject *result;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
assert(src != NULL);
|
|
|
|
i = src->ob_size;
|
|
|
|
if (i < 0)
|
|
|
|
i = -(i);
|
|
|
|
result = _PyLong_New(i);
|
|
|
|
if (result != NULL) {
|
2002-03-02 00:18:04 -04:00
|
|
|
result->ob_size = src->ob_size;
|
2001-09-10 17:52:51 -03:00
|
|
|
while (--i >= 0)
|
|
|
|
result->ob_digit[i] = src->ob_digit[i];
|
|
|
|
}
|
|
|
|
return (PyObject *)result;
|
|
|
|
}
|
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
/* Create a new long int object from a C long int */
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
PyObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
PyLong_FromLong(long ival)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
2001-06-14 01:56:19 -03:00
|
|
|
PyLongObject *v;
|
|
|
|
unsigned long t; /* unsigned so >> doesn't propagate sign bit */
|
|
|
|
int ndigits = 0;
|
|
|
|
int negative = 0;
|
|
|
|
|
|
|
|
if (ival < 0) {
|
|
|
|
ival = -ival;
|
|
|
|
negative = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Count the number of Python digits.
|
|
|
|
We used to pick 5 ("big enough for anything"), but that's a
|
|
|
|
waste of time and space given that 5*15 = 75 bits are rarely
|
|
|
|
needed. */
|
|
|
|
t = (unsigned long)ival;
|
|
|
|
while (t) {
|
|
|
|
++ndigits;
|
|
|
|
t >>= SHIFT;
|
|
|
|
}
|
|
|
|
v = _PyLong_New(ndigits);
|
1991-05-05 17:09:44 -03:00
|
|
|
if (v != NULL) {
|
2001-06-14 01:56:19 -03:00
|
|
|
digit *p = v->ob_digit;
|
|
|
|
v->ob_size = negative ? -ndigits : ndigits;
|
|
|
|
t = (unsigned long)ival;
|
|
|
|
while (t) {
|
|
|
|
*p++ = (digit)(t & MASK);
|
1996-12-05 17:57:21 -04:00
|
|
|
t >>= SHIFT;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
return (PyObject *)v;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
|
1997-01-03 13:14:46 -04:00
|
|
|
/* Create a new long int object from a C unsigned long int */
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
PyObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
PyLong_FromUnsignedLong(unsigned long ival)
|
1997-01-03 13:14:46 -04:00
|
|
|
{
|
2001-06-14 01:56:19 -03:00
|
|
|
PyLongObject *v;
|
|
|
|
unsigned long t;
|
|
|
|
int ndigits = 0;
|
|
|
|
|
|
|
|
/* Count the number of Python digits. */
|
|
|
|
t = (unsigned long)ival;
|
|
|
|
while (t) {
|
|
|
|
++ndigits;
|
|
|
|
t >>= SHIFT;
|
|
|
|
}
|
|
|
|
v = _PyLong_New(ndigits);
|
1997-01-03 13:14:46 -04:00
|
|
|
if (v != NULL) {
|
2001-06-14 01:56:19 -03:00
|
|
|
digit *p = v->ob_digit;
|
|
|
|
v->ob_size = ndigits;
|
|
|
|
while (ival) {
|
|
|
|
*p++ = (digit)(ival & MASK);
|
|
|
|
ival >>= SHIFT;
|
1997-01-03 13:14:46 -04:00
|
|
|
}
|
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
return (PyObject *)v;
|
1997-01-03 13:14:46 -04:00
|
|
|
}
|
|
|
|
|
1991-06-03 07:58:24 -03:00
|
|
|
/* Create a new long int object from a C double */
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
PyObject *
|
|
|
|
PyLong_FromDouble(double dval)
|
1991-06-03 07:58:24 -03:00
|
|
|
{
|
1997-05-02 00:12:38 -03:00
|
|
|
PyLongObject *v;
|
1991-06-03 07:58:24 -03:00
|
|
|
double frac;
|
|
|
|
int i, ndig, expo, neg;
|
|
|
|
neg = 0;
|
2000-08-15 00:34:48 -03:00
|
|
|
if (Py_IS_INFINITY(dval)) {
|
1999-09-27 14:11:52 -03:00
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
|
|
"cannot convert float infinity to long");
|
|
|
|
return NULL;
|
|
|
|
}
|
1991-06-03 07:58:24 -03:00
|
|
|
if (dval < 0.0) {
|
|
|
|
neg = 1;
|
|
|
|
dval = -dval;
|
|
|
|
}
|
|
|
|
frac = frexp(dval, &expo); /* dval = frac*2**expo; 0.0 <= frac < 1.0 */
|
|
|
|
if (expo <= 0)
|
1997-05-02 00:12:38 -03:00
|
|
|
return PyLong_FromLong(0L);
|
1991-06-03 07:58:24 -03:00
|
|
|
ndig = (expo-1) / SHIFT + 1; /* Number of 'digits' in result */
|
1997-05-02 00:12:38 -03:00
|
|
|
v = _PyLong_New(ndig);
|
1991-06-03 07:58:24 -03:00
|
|
|
if (v == NULL)
|
|
|
|
return NULL;
|
|
|
|
frac = ldexp(frac, (expo-1) % SHIFT + 1);
|
|
|
|
for (i = ndig; --i >= 0; ) {
|
|
|
|
long bits = (long)frac;
|
1997-04-09 16:41:24 -03:00
|
|
|
v->ob_digit[i] = (digit) bits;
|
1991-06-03 07:58:24 -03:00
|
|
|
frac = frac - (double)bits;
|
|
|
|
frac = ldexp(frac, SHIFT);
|
|
|
|
}
|
|
|
|
if (neg)
|
1992-01-14 14:36:43 -04:00
|
|
|
v->ob_size = -(v->ob_size);
|
1997-05-02 00:12:38 -03:00
|
|
|
return (PyObject *)v;
|
1991-06-03 07:58:24 -03:00
|
|
|
}
|
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
/* Get a C long int from a long int object.
|
|
|
|
Returns -1 and sets an error condition if overflow occurs. */
|
|
|
|
|
|
|
|
long
|
2000-07-07 12:53:28 -03:00
|
|
|
PyLong_AsLong(PyObject *vv)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
Subject: Buglet in PyLong_AsLong
From: "Tim Peters" <tim_one@email.msn.com>
To: "Guido van Rossum" <guido@CNRI.Reston.VA.US>
Date: Sat, 23 May 1998 21:45:53 -0400
Guido, the overflow checking in PyLong_AsLong is off a little:
1) If the C in use sign-extends right shifts on signed longs, there's a
spurious overflow error when converting the most-negative int:
Python 1.5.1 (#0, Apr 13 1998, 20:22:04) [MSC 32 bit (Intel)] on win32
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> x = -1L << 31
>>> x
-2147483648L
>>> int(x)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>>
2) If C does not sign-extend, some genuine overflows won't be caught.
The attached should repair both, and, because I installed a new disk and a C
compiler today, it's even been compiled this time <wink>.
Python 1.5.1 (#0, May 23 1998, 20:24:58) [MSC 32 bit (Intel)] on win32
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> x = -1L << 31
>>> x
-2147483648L
>>> int(x)
-2147483648
>>> int(-x)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>> int(-x-1)
2147483647
>>> int(x-1)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>>
end-casing-ly y'rs - tim
1998-05-26 11:33:37 -03:00
|
|
|
/* This version by Tim Peters */
|
1997-05-02 00:12:38 -03:00
|
|
|
register PyLongObject *v;
|
Subject: Buglet in PyLong_AsLong
From: "Tim Peters" <tim_one@email.msn.com>
To: "Guido van Rossum" <guido@CNRI.Reston.VA.US>
Date: Sat, 23 May 1998 21:45:53 -0400
Guido, the overflow checking in PyLong_AsLong is off a little:
1) If the C in use sign-extends right shifts on signed longs, there's a
spurious overflow error when converting the most-negative int:
Python 1.5.1 (#0, Apr 13 1998, 20:22:04) [MSC 32 bit (Intel)] on win32
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> x = -1L << 31
>>> x
-2147483648L
>>> int(x)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>>
2) If C does not sign-extend, some genuine overflows won't be caught.
The attached should repair both, and, because I installed a new disk and a C
compiler today, it's even been compiled this time <wink>.
Python 1.5.1 (#0, May 23 1998, 20:24:58) [MSC 32 bit (Intel)] on win32
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> x = -1L << 31
>>> x
-2147483648L
>>> int(x)
-2147483648
>>> int(-x)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>> int(-x-1)
2147483647
>>> int(x-1)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>>
end-casing-ly y'rs - tim
1998-05-26 11:33:37 -03:00
|
|
|
unsigned long x, prev;
|
1991-05-05 17:09:44 -03:00
|
|
|
int i, sign;
|
Subject: Buglet in PyLong_AsLong
From: "Tim Peters" <tim_one@email.msn.com>
To: "Guido van Rossum" <guido@CNRI.Reston.VA.US>
Date: Sat, 23 May 1998 21:45:53 -0400
Guido, the overflow checking in PyLong_AsLong is off a little:
1) If the C in use sign-extends right shifts on signed longs, there's a
spurious overflow error when converting the most-negative int:
Python 1.5.1 (#0, Apr 13 1998, 20:22:04) [MSC 32 bit (Intel)] on win32
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> x = -1L << 31
>>> x
-2147483648L
>>> int(x)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>>
2) If C does not sign-extend, some genuine overflows won't be caught.
The attached should repair both, and, because I installed a new disk and a C
compiler today, it's even been compiled this time <wink>.
Python 1.5.1 (#0, May 23 1998, 20:24:58) [MSC 32 bit (Intel)] on win32
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> x = -1L << 31
>>> x
-2147483648L
>>> int(x)
-2147483648
>>> int(-x)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>> int(-x-1)
2147483647
>>> int(x-1)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>>
end-casing-ly y'rs - tim
1998-05-26 11:33:37 -03:00
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
if (vv == NULL || !PyLong_Check(vv)) {
|
2001-09-15 00:14:32 -03:00
|
|
|
if (vv != NULL && PyInt_Check(vv))
|
|
|
|
return PyInt_AsLong(vv);
|
1997-05-02 00:12:38 -03:00
|
|
|
PyErr_BadInternalCall();
|
1991-05-05 17:09:44 -03:00
|
|
|
return -1;
|
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
v = (PyLongObject *)vv;
|
1991-05-05 17:09:44 -03:00
|
|
|
i = v->ob_size;
|
|
|
|
sign = 1;
|
|
|
|
x = 0;
|
|
|
|
if (i < 0) {
|
|
|
|
sign = -1;
|
1992-01-14 14:36:43 -04:00
|
|
|
i = -(i);
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
while (--i >= 0) {
|
|
|
|
prev = x;
|
|
|
|
x = (x << SHIFT) + v->ob_digit[i];
|
Subject: Buglet in PyLong_AsLong
From: "Tim Peters" <tim_one@email.msn.com>
To: "Guido van Rossum" <guido@CNRI.Reston.VA.US>
Date: Sat, 23 May 1998 21:45:53 -0400
Guido, the overflow checking in PyLong_AsLong is off a little:
1) If the C in use sign-extends right shifts on signed longs, there's a
spurious overflow error when converting the most-negative int:
Python 1.5.1 (#0, Apr 13 1998, 20:22:04) [MSC 32 bit (Intel)] on win32
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> x = -1L << 31
>>> x
-2147483648L
>>> int(x)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>>
2) If C does not sign-extend, some genuine overflows won't be caught.
The attached should repair both, and, because I installed a new disk and a C
compiler today, it's even been compiled this time <wink>.
Python 1.5.1 (#0, May 23 1998, 20:24:58) [MSC 32 bit (Intel)] on win32
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> x = -1L << 31
>>> x
-2147483648L
>>> int(x)
-2147483648
>>> int(-x)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>> int(-x-1)
2147483647
>>> int(x-1)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>>
end-casing-ly y'rs - tim
1998-05-26 11:33:37 -03:00
|
|
|
if ((x >> SHIFT) != prev)
|
|
|
|
goto overflow;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
Subject: Buglet in PyLong_AsLong
From: "Tim Peters" <tim_one@email.msn.com>
To: "Guido van Rossum" <guido@CNRI.Reston.VA.US>
Date: Sat, 23 May 1998 21:45:53 -0400
Guido, the overflow checking in PyLong_AsLong is off a little:
1) If the C in use sign-extends right shifts on signed longs, there's a
spurious overflow error when converting the most-negative int:
Python 1.5.1 (#0, Apr 13 1998, 20:22:04) [MSC 32 bit (Intel)] on win32
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> x = -1L << 31
>>> x
-2147483648L
>>> int(x)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>>
2) If C does not sign-extend, some genuine overflows won't be caught.
The attached should repair both, and, because I installed a new disk and a C
compiler today, it's even been compiled this time <wink>.
Python 1.5.1 (#0, May 23 1998, 20:24:58) [MSC 32 bit (Intel)] on win32
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> x = -1L << 31
>>> x
-2147483648L
>>> int(x)
-2147483648
>>> int(-x)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>> int(-x-1)
2147483647
>>> int(x-1)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>>
end-casing-ly y'rs - tim
1998-05-26 11:33:37 -03:00
|
|
|
/* Haven't lost any bits, but if the sign bit is set we're in
|
|
|
|
* trouble *unless* this is the min negative number. So,
|
|
|
|
* trouble iff sign bit set && (positive || some bit set other
|
|
|
|
* than the sign bit).
|
|
|
|
*/
|
|
|
|
if ((long)x < 0 && (sign > 0 || (x << 1) != 0))
|
|
|
|
goto overflow;
|
|
|
|
return (long)x * sign;
|
|
|
|
|
|
|
|
overflow:
|
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
2001-09-13 16:05:30 -03:00
|
|
|
"long int too large to convert to int");
|
Subject: Buglet in PyLong_AsLong
From: "Tim Peters" <tim_one@email.msn.com>
To: "Guido van Rossum" <guido@CNRI.Reston.VA.US>
Date: Sat, 23 May 1998 21:45:53 -0400
Guido, the overflow checking in PyLong_AsLong is off a little:
1) If the C in use sign-extends right shifts on signed longs, there's a
spurious overflow error when converting the most-negative int:
Python 1.5.1 (#0, Apr 13 1998, 20:22:04) [MSC 32 bit (Intel)] on win32
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> x = -1L << 31
>>> x
-2147483648L
>>> int(x)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>>
2) If C does not sign-extend, some genuine overflows won't be caught.
The attached should repair both, and, because I installed a new disk and a C
compiler today, it's even been compiled this time <wink>.
Python 1.5.1 (#0, May 23 1998, 20:24:58) [MSC 32 bit (Intel)] on win32
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> x = -1L << 31
>>> x
-2147483648L
>>> int(x)
-2147483648
>>> int(-x)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>> int(-x-1)
2147483647
>>> int(x-1)
Traceback (innermost last):
File "<stdin>", line 1, in ?
OverflowError: long int too long to convert
>>>
end-casing-ly y'rs - tim
1998-05-26 11:33:37 -03:00
|
|
|
return -1;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
|
2002-08-12 21:24:58 -03:00
|
|
|
/* Get a C unsigned long int from a long int object.
|
1997-01-03 13:14:46 -04:00
|
|
|
Returns -1 and sets an error condition if overflow occurs. */
|
|
|
|
|
|
|
|
unsigned long
|
2000-07-07 12:53:28 -03:00
|
|
|
PyLong_AsUnsignedLong(PyObject *vv)
|
1997-01-03 13:14:46 -04:00
|
|
|
{
|
1997-05-02 00:12:38 -03:00
|
|
|
register PyLongObject *v;
|
1997-01-03 13:14:46 -04:00
|
|
|
unsigned long x, prev;
|
|
|
|
int i;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
if (vv == NULL || !PyLong_Check(vv)) {
|
2004-09-20 03:17:46 -03:00
|
|
|
if (vv != NULL && PyInt_Check(vv)) {
|
|
|
|
long val = PyInt_AsLong(vv);
|
|
|
|
if (val < 0) {
|
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
|
|
"can't convert negative value to unsigned long");
|
|
|
|
return (unsigned long) -1;
|
|
|
|
}
|
|
|
|
return val;
|
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
PyErr_BadInternalCall();
|
1997-01-03 13:14:46 -04:00
|
|
|
return (unsigned long) -1;
|
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
v = (PyLongObject *)vv;
|
1997-01-03 13:14:46 -04:00
|
|
|
i = v->ob_size;
|
|
|
|
x = 0;
|
|
|
|
if (i < 0) {
|
1997-05-02 00:12:38 -03:00
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
1997-01-03 13:14:46 -04:00
|
|
|
"can't convert negative value to unsigned long");
|
|
|
|
return (unsigned long) -1;
|
|
|
|
}
|
|
|
|
while (--i >= 0) {
|
|
|
|
prev = x;
|
|
|
|
x = (x << SHIFT) + v->ob_digit[i];
|
|
|
|
if ((x >> SHIFT) != prev) {
|
1997-05-02 00:12:38 -03:00
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
2000-10-24 16:57:45 -03:00
|
|
|
"long int too large to convert");
|
1997-01-03 13:14:46 -04:00
|
|
|
return (unsigned long) -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
2003-04-17 15:55:45 -03:00
|
|
|
/* Get a C unsigned long int from a long int object, ignoring the high bits.
|
|
|
|
Returns -1 and sets an error condition if an error occurs. */
|
|
|
|
|
|
|
|
unsigned long
|
|
|
|
PyLong_AsUnsignedLongMask(PyObject *vv)
|
|
|
|
{
|
|
|
|
register PyLongObject *v;
|
|
|
|
unsigned long x;
|
|
|
|
int i, sign;
|
|
|
|
|
|
|
|
if (vv == NULL || !PyLong_Check(vv)) {
|
2004-09-20 03:17:46 -03:00
|
|
|
if (vv != NULL && PyInt_Check(vv))
|
|
|
|
return PyInt_AsUnsignedLongMask(vv);
|
2003-04-17 15:55:45 -03:00
|
|
|
PyErr_BadInternalCall();
|
|
|
|
return (unsigned long) -1;
|
|
|
|
}
|
|
|
|
v = (PyLongObject *)vv;
|
|
|
|
i = v->ob_size;
|
|
|
|
sign = 1;
|
|
|
|
x = 0;
|
|
|
|
if (i < 0) {
|
|
|
|
sign = -1;
|
|
|
|
i = -i;
|
|
|
|
}
|
|
|
|
while (--i >= 0) {
|
|
|
|
x = (x << SHIFT) + v->ob_digit[i];
|
|
|
|
}
|
|
|
|
return x * sign;
|
|
|
|
}
|
|
|
|
|
2003-01-31 11:52:05 -04:00
|
|
|
int
|
|
|
|
_PyLong_Sign(PyObject *vv)
|
|
|
|
{
|
|
|
|
PyLongObject *v = (PyLongObject *)vv;
|
|
|
|
|
|
|
|
assert(v != NULL);
|
|
|
|
assert(PyLong_Check(v));
|
|
|
|
|
cPickle.c: Full support for the new LONG1 and LONG4. Added comments.
Assorted code cleanups; e.g., sizeof(char) is 1 by definition, so there's
no need to do things like multiply by sizeof(char) in hairy malloc
arguments. Fixed an undetected-overflow bug in readline_file().
longobject.c: Fixed a really stupid bug in the new _PyLong_NumBits.
pickle.py: Fixed stupid bug in save_long(): When proto is 2, it
wrote LONG1 or LONG4, but forgot to return then -- it went on to
append the proto 1 LONG opcode too.
Fixed equally stupid cancelling bugs in load_long1() and
load_long4(): they *returned* the unpickled long instead of pushing
it on the stack. The return values were ignored. Tests passed
before only because save_long() pickled the long twice.
Fixed bugs in encode_long().
Noted that decode_long() is quadratic-time despite our hopes,
because long(string, 16) is still quadratic-time in len(string).
It's hex() that's linear-time. I don't know a way to make decode_long()
linear-time in Python, short of maybe transforming the 256's-complement
bytes into marshal's funky internal format, and letting marshal decode
that. It would be more valuable to make long(string, 16) linear time.
pickletester.py: Added a global "protocols" vector so tests can try
all the protocols in a sane way. Changed test_ints() and test_unicode()
to do so. Added a new test_long(), but the tail end of it is disabled
because it "takes forever" under pickle.py (but runs very quickly under
cPickle: cPickle proto 2 for longs is linear-time).
2003-02-01 22:57:53 -04:00
|
|
|
return v->ob_size == 0 ? 0 : (v->ob_size < 0 ? -1 : 1);
|
2003-01-31 11:52:05 -04:00
|
|
|
}
|
|
|
|
|
2003-01-28 16:37:45 -04:00
|
|
|
size_t
|
|
|
|
_PyLong_NumBits(PyObject *vv)
|
|
|
|
{
|
|
|
|
PyLongObject *v = (PyLongObject *)vv;
|
2003-01-31 11:52:05 -04:00
|
|
|
size_t result = 0;
|
2003-02-03 11:28:19 -04:00
|
|
|
int ndigits;
|
2003-01-28 16:37:45 -04:00
|
|
|
|
|
|
|
assert(v != NULL);
|
|
|
|
assert(PyLong_Check(v));
|
2003-02-03 11:28:19 -04:00
|
|
|
ndigits = ABS(v->ob_size);
|
2003-01-28 16:37:45 -04:00
|
|
|
assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0);
|
|
|
|
if (ndigits > 0) {
|
|
|
|
digit msd = v->ob_digit[ndigits - 1];
|
|
|
|
|
2003-01-31 11:52:05 -04:00
|
|
|
result = (ndigits - 1) * SHIFT;
|
2003-01-31 17:45:13 -04:00
|
|
|
if (result / SHIFT != (size_t)ndigits - 1)
|
2003-01-28 16:37:45 -04:00
|
|
|
goto Overflow;
|
|
|
|
do {
|
|
|
|
++result;
|
|
|
|
if (result == 0)
|
|
|
|
goto Overflow;
|
|
|
|
msd >>= 1;
|
|
|
|
} while (msd);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
|
|
|
|
Overflow:
|
|
|
|
PyErr_SetString(PyExc_OverflowError, "long has too many bits "
|
|
|
|
"to express in a platform size_t");
|
|
|
|
return (size_t)-1;
|
|
|
|
}
|
|
|
|
|
2001-06-11 18:23:58 -03:00
|
|
|
PyObject *
|
|
|
|
_PyLong_FromByteArray(const unsigned char* bytes, size_t n,
|
|
|
|
int little_endian, int is_signed)
|
|
|
|
{
|
|
|
|
const unsigned char* pstartbyte;/* LSB of bytes */
|
|
|
|
int incr; /* direction to move pstartbyte */
|
|
|
|
const unsigned char* pendbyte; /* MSB of bytes */
|
|
|
|
size_t numsignificantbytes; /* number of bytes that matter */
|
|
|
|
size_t ndigits; /* number of Python long digits */
|
|
|
|
PyLongObject* v; /* result */
|
|
|
|
int idigit = 0; /* next free index in v->ob_digit */
|
|
|
|
|
|
|
|
if (n == 0)
|
|
|
|
return PyLong_FromLong(0L);
|
|
|
|
|
|
|
|
if (little_endian) {
|
|
|
|
pstartbyte = bytes;
|
|
|
|
pendbyte = bytes + n - 1;
|
|
|
|
incr = 1;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
pstartbyte = bytes + n - 1;
|
|
|
|
pendbyte = bytes;
|
|
|
|
incr = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (is_signed)
|
|
|
|
is_signed = *pendbyte >= 0x80;
|
|
|
|
|
|
|
|
/* Compute numsignificantbytes. This consists of finding the most
|
|
|
|
significant byte. Leading 0 bytes are insignficant if the number
|
|
|
|
is positive, and leading 0xff bytes if negative. */
|
|
|
|
{
|
|
|
|
size_t i;
|
|
|
|
const unsigned char* p = pendbyte;
|
|
|
|
const int pincr = -incr; /* search MSB to LSB */
|
|
|
|
const unsigned char insignficant = is_signed ? 0xff : 0x00;
|
|
|
|
|
|
|
|
for (i = 0; i < n; ++i, p += pincr) {
|
|
|
|
if (*p != insignficant)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
numsignificantbytes = n - i;
|
|
|
|
/* 2's-comp is a bit tricky here, e.g. 0xff00 == -0x0100, so
|
|
|
|
actually has 2 significant bytes. OTOH, 0xff0001 ==
|
|
|
|
-0x00ffff, so we wouldn't *need* to bump it there; but we
|
|
|
|
do for 0xffff = -0x0001. To be safe without bothering to
|
|
|
|
check every case, bump it regardless. */
|
|
|
|
if (is_signed && numsignificantbytes < n)
|
|
|
|
++numsignificantbytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* How many Python long digits do we need? We have
|
|
|
|
8*numsignificantbytes bits, and each Python long digit has SHIFT
|
|
|
|
bits, so it's the ceiling of the quotient. */
|
|
|
|
ndigits = (numsignificantbytes * 8 + SHIFT - 1) / SHIFT;
|
|
|
|
if (ndigits > (size_t)INT_MAX)
|
|
|
|
return PyErr_NoMemory();
|
|
|
|
v = _PyLong_New((int)ndigits);
|
|
|
|
if (v == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* Copy the bits over. The tricky parts are computing 2's-comp on
|
|
|
|
the fly for signed numbers, and dealing with the mismatch between
|
|
|
|
8-bit bytes and (probably) 15-bit Python digits.*/
|
|
|
|
{
|
|
|
|
size_t i;
|
2001-06-13 18:09:15 -03:00
|
|
|
twodigits carry = 1; /* for 2's-comp calculation */
|
2001-06-11 18:23:58 -03:00
|
|
|
twodigits accum = 0; /* sliding register */
|
|
|
|
unsigned int accumbits = 0; /* number of bits in accum */
|
|
|
|
const unsigned char* p = pstartbyte;
|
|
|
|
|
|
|
|
for (i = 0; i < numsignificantbytes; ++i, p += incr) {
|
2001-06-12 16:17:03 -03:00
|
|
|
twodigits thisbyte = *p;
|
2001-06-11 18:23:58 -03:00
|
|
|
/* Compute correction for 2's comp, if needed. */
|
|
|
|
if (is_signed) {
|
|
|
|
thisbyte = (0xff ^ thisbyte) + carry;
|
|
|
|
carry = thisbyte >> 8;
|
|
|
|
thisbyte &= 0xff;
|
|
|
|
}
|
|
|
|
/* Because we're going LSB to MSB, thisbyte is
|
|
|
|
more significant than what's already in accum,
|
|
|
|
so needs to be prepended to accum. */
|
|
|
|
accum |= thisbyte << accumbits;
|
|
|
|
accumbits += 8;
|
|
|
|
if (accumbits >= SHIFT) {
|
|
|
|
/* There's enough to fill a Python digit. */
|
|
|
|
assert(idigit < (int)ndigits);
|
|
|
|
v->ob_digit[idigit] = (digit)(accum & MASK);
|
|
|
|
++idigit;
|
|
|
|
accum >>= SHIFT;
|
|
|
|
accumbits -= SHIFT;
|
|
|
|
assert(accumbits < SHIFT);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert(accumbits < SHIFT);
|
|
|
|
if (accumbits) {
|
|
|
|
assert(idigit < (int)ndigits);
|
|
|
|
v->ob_digit[idigit] = (digit)accum;
|
|
|
|
++idigit;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
v->ob_size = is_signed ? -idigit : idigit;
|
|
|
|
return (PyObject *)long_normalize(v);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
_PyLong_AsByteArray(PyLongObject* v,
|
|
|
|
unsigned char* bytes, size_t n,
|
|
|
|
int little_endian, int is_signed)
|
|
|
|
{
|
|
|
|
int i; /* index into v->ob_digit */
|
|
|
|
int ndigits; /* |v->ob_size| */
|
|
|
|
twodigits accum; /* sliding register */
|
|
|
|
unsigned int accumbits; /* # bits in accum */
|
|
|
|
int do_twos_comp; /* store 2's-comp? is_signed and v < 0 */
|
|
|
|
twodigits carry; /* for computing 2's-comp */
|
|
|
|
size_t j; /* # bytes filled */
|
|
|
|
unsigned char* p; /* pointer to next byte in bytes */
|
|
|
|
int pincr; /* direction to move p */
|
|
|
|
|
|
|
|
assert(v != NULL && PyLong_Check(v));
|
|
|
|
|
|
|
|
if (v->ob_size < 0) {
|
|
|
|
ndigits = -(v->ob_size);
|
|
|
|
if (!is_signed) {
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
"can't convert negative long to unsigned");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
do_twos_comp = 1;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ndigits = v->ob_size;
|
|
|
|
do_twos_comp = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (little_endian) {
|
|
|
|
p = bytes;
|
|
|
|
pincr = 1;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
p = bytes + n - 1;
|
|
|
|
pincr = -1;
|
|
|
|
}
|
|
|
|
|
2001-06-13 17:50:08 -03:00
|
|
|
/* Copy over all the Python digits.
|
|
|
|
It's crucial that every Python digit except for the MSD contribute
|
|
|
|
exactly SHIFT bits to the total, so first assert that the long is
|
|
|
|
normalized. */
|
|
|
|
assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0);
|
2001-06-11 18:23:58 -03:00
|
|
|
j = 0;
|
|
|
|
accum = 0;
|
|
|
|
accumbits = 0;
|
|
|
|
carry = do_twos_comp ? 1 : 0;
|
|
|
|
for (i = 0; i < ndigits; ++i) {
|
|
|
|
twodigits thisdigit = v->ob_digit[i];
|
|
|
|
if (do_twos_comp) {
|
|
|
|
thisdigit = (thisdigit ^ MASK) + carry;
|
|
|
|
carry = thisdigit >> SHIFT;
|
|
|
|
thisdigit &= MASK;
|
|
|
|
}
|
2001-06-12 16:17:03 -03:00
|
|
|
/* Because we're going LSB to MSB, thisdigit is more
|
|
|
|
significant than what's already in accum, so needs to be
|
|
|
|
prepended to accum. */
|
|
|
|
accum |= thisdigit << accumbits;
|
2001-06-14 05:53:38 -03:00
|
|
|
accumbits += SHIFT;
|
2001-06-12 16:17:03 -03:00
|
|
|
|
2001-06-14 05:53:38 -03:00
|
|
|
/* The most-significant digit may be (probably is) at least
|
|
|
|
partly empty. */
|
2001-06-12 16:17:03 -03:00
|
|
|
if (i == ndigits - 1) {
|
2001-06-14 05:53:38 -03:00
|
|
|
/* Count # of sign bits -- they needn't be stored,
|
|
|
|
* although for signed conversion we need later to
|
|
|
|
* make sure at least one sign bit gets stored.
|
|
|
|
* First shift conceptual sign bit to real sign bit.
|
|
|
|
*/
|
|
|
|
stwodigits s = (stwodigits)(thisdigit <<
|
|
|
|
(8*sizeof(stwodigits) - SHIFT));
|
2001-06-11 22:22:22 -03:00
|
|
|
unsigned int nsignbits = 0;
|
2001-06-14 05:53:38 -03:00
|
|
|
while ((s < 0) == do_twos_comp && nsignbits < SHIFT) {
|
2001-06-11 22:22:22 -03:00
|
|
|
++nsignbits;
|
2001-06-14 05:53:38 -03:00
|
|
|
s <<= 1;
|
2001-06-11 22:22:22 -03:00
|
|
|
}
|
2001-06-14 05:53:38 -03:00
|
|
|
accumbits -= nsignbits;
|
2001-06-11 22:22:22 -03:00
|
|
|
}
|
2001-06-12 16:17:03 -03:00
|
|
|
|
2001-06-11 18:23:58 -03:00
|
|
|
/* Store as many bytes as possible. */
|
2001-06-11 22:22:22 -03:00
|
|
|
while (accumbits >= 8) {
|
2001-06-11 18:23:58 -03:00
|
|
|
if (j >= n)
|
|
|
|
goto Overflow;
|
|
|
|
++j;
|
|
|
|
*p = (unsigned char)(accum & 0xff);
|
|
|
|
p += pincr;
|
|
|
|
accumbits -= 8;
|
|
|
|
accum >>= 8;
|
2001-06-11 22:22:22 -03:00
|
|
|
}
|
2001-06-11 18:23:58 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Store the straggler (if any). */
|
|
|
|
assert(accumbits < 8);
|
|
|
|
assert(carry == 0); /* else do_twos_comp and *every* digit was 0 */
|
2001-06-11 22:22:22 -03:00
|
|
|
if (accumbits > 0) {
|
2001-06-11 18:23:58 -03:00
|
|
|
if (j >= n)
|
|
|
|
goto Overflow;
|
|
|
|
++j;
|
|
|
|
if (do_twos_comp) {
|
|
|
|
/* Fill leading bits of the byte with sign bits
|
|
|
|
(appropriately pretending that the long had an
|
|
|
|
infinite supply of sign bits). */
|
|
|
|
accum |= (~(twodigits)0) << accumbits;
|
|
|
|
}
|
|
|
|
*p = (unsigned char)(accum & 0xff);
|
|
|
|
p += pincr;
|
|
|
|
}
|
2001-06-13 18:01:27 -03:00
|
|
|
else if (j == n && n > 0 && is_signed) {
|
|
|
|
/* The main loop filled the byte array exactly, so the code
|
|
|
|
just above didn't get to ensure there's a sign bit, and the
|
|
|
|
loop below wouldn't add one either. Make sure a sign bit
|
|
|
|
exists. */
|
2001-06-11 18:23:58 -03:00
|
|
|
unsigned char msb = *(p - pincr);
|
2001-06-13 18:01:27 -03:00
|
|
|
int sign_bit_set = msb >= 0x80;
|
|
|
|
assert(accumbits == 0);
|
|
|
|
if (sign_bit_set == do_twos_comp)
|
|
|
|
return 0;
|
|
|
|
else
|
2001-06-11 18:23:58 -03:00
|
|
|
goto Overflow;
|
|
|
|
}
|
2001-06-13 18:01:27 -03:00
|
|
|
|
|
|
|
/* Fill remaining bytes with copies of the sign bit. */
|
|
|
|
{
|
|
|
|
unsigned char signbyte = do_twos_comp ? 0xffU : 0U;
|
|
|
|
for ( ; j < n; ++j, p += pincr)
|
|
|
|
*p = signbyte;
|
|
|
|
}
|
|
|
|
|
2001-06-11 18:23:58 -03:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
Overflow:
|
|
|
|
PyErr_SetString(PyExc_OverflowError, "long too big to convert");
|
|
|
|
return -1;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
2001-06-11 18:23:58 -03:00
|
|
|
}
|
|
|
|
|
2001-09-03 23:50:49 -03:00
|
|
|
double
|
|
|
|
_PyLong_AsScaledDouble(PyObject *vv, int *exponent)
|
|
|
|
{
|
|
|
|
/* NBITS_WANTED should be > the number of bits in a double's precision,
|
|
|
|
but small enough so that 2**NBITS_WANTED is within the normal double
|
|
|
|
range. nbitsneeded is set to 1 less than that because the most-significant
|
|
|
|
Python digit contains at least 1 significant bit, but we don't want to
|
|
|
|
bother counting them (catering to the worst case cheaply).
|
|
|
|
|
|
|
|
57 is one more than VAX-D double precision; I (Tim) don't know of a double
|
|
|
|
format with more precision than that; it's 1 larger so that we add in at
|
|
|
|
least one round bit to stand in for the ignored least-significant bits.
|
|
|
|
*/
|
|
|
|
#define NBITS_WANTED 57
|
|
|
|
PyLongObject *v;
|
|
|
|
double x;
|
|
|
|
const double multiplier = (double)(1L << SHIFT);
|
|
|
|
int i, sign;
|
|
|
|
int nbitsneeded;
|
|
|
|
|
|
|
|
if (vv == NULL || !PyLong_Check(vv)) {
|
|
|
|
PyErr_BadInternalCall();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
v = (PyLongObject *)vv;
|
|
|
|
i = v->ob_size;
|
|
|
|
sign = 1;
|
|
|
|
if (i < 0) {
|
|
|
|
sign = -1;
|
|
|
|
i = -(i);
|
|
|
|
}
|
|
|
|
else if (i == 0) {
|
|
|
|
*exponent = 0;
|
|
|
|
return 0.0;
|
|
|
|
}
|
|
|
|
--i;
|
|
|
|
x = (double)v->ob_digit[i];
|
|
|
|
nbitsneeded = NBITS_WANTED - 1;
|
|
|
|
/* Invariant: i Python digits remain unaccounted for. */
|
|
|
|
while (i > 0 && nbitsneeded > 0) {
|
|
|
|
--i;
|
|
|
|
x = x * multiplier + (double)v->ob_digit[i];
|
|
|
|
nbitsneeded -= SHIFT;
|
|
|
|
}
|
|
|
|
/* There are i digits we didn't shift in. Pretending they're all
|
|
|
|
zeroes, the true value is x * 2**(i*SHIFT). */
|
|
|
|
*exponent = i;
|
|
|
|
assert(x > 0.0);
|
|
|
|
return x * sign;
|
|
|
|
#undef NBITS_WANTED
|
|
|
|
}
|
|
|
|
|
1997-02-14 18:54:21 -04:00
|
|
|
/* Get a C double from a long int object. */
|
1991-05-05 17:09:44 -03:00
|
|
|
|
|
|
|
double
|
2000-07-07 12:53:28 -03:00
|
|
|
PyLong_AsDouble(PyObject *vv)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
2001-09-04 02:14:19 -03:00
|
|
|
int e;
|
1991-05-05 17:09:44 -03:00
|
|
|
double x;
|
2001-09-04 02:14:19 -03:00
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
if (vv == NULL || !PyLong_Check(vv)) {
|
|
|
|
PyErr_BadInternalCall();
|
1991-05-05 17:09:44 -03:00
|
|
|
return -1;
|
|
|
|
}
|
2001-09-04 02:14:19 -03:00
|
|
|
x = _PyLong_AsScaledDouble(vv, &e);
|
|
|
|
if (x == -1.0 && PyErr_Occurred())
|
|
|
|
return -1.0;
|
|
|
|
if (e > INT_MAX / SHIFT)
|
|
|
|
goto overflow;
|
|
|
|
errno = 0;
|
|
|
|
x = ldexp(x, e * SHIFT);
|
2001-09-05 02:38:10 -03:00
|
|
|
if (Py_OVERFLOWED(x))
|
2001-09-04 02:14:19 -03:00
|
|
|
goto overflow;
|
|
|
|
return x;
|
|
|
|
|
|
|
|
overflow:
|
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
|
|
"long int too large to convert to float");
|
|
|
|
return -1.0;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
|
1998-09-18 11:14:13 -03:00
|
|
|
/* Create a new long (or int) object from a C pointer */
|
|
|
|
|
|
|
|
PyObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
PyLong_FromVoidPtr(void *p)
|
1998-09-18 11:14:13 -03:00
|
|
|
{
|
2001-06-16 05:48:40 -03:00
|
|
|
#if SIZEOF_VOID_P <= SIZEOF_LONG
|
1998-09-18 11:14:13 -03:00
|
|
|
return PyInt_FromLong((long)p);
|
|
|
|
#else
|
2001-06-16 05:48:40 -03:00
|
|
|
|
|
|
|
#ifndef HAVE_LONG_LONG
|
|
|
|
# error "PyLong_FromVoidPtr: sizeof(void*) > sizeof(long), but no long long"
|
|
|
|
#endif
|
|
|
|
#if SIZEOF_LONG_LONG < SIZEOF_VOID_P
|
2003-03-29 06:06:18 -04:00
|
|
|
# error "PyLong_FromVoidPtr: sizeof(PY_LONG_LONG) < sizeof(void*)"
|
2001-06-16 05:48:40 -03:00
|
|
|
#endif
|
1998-09-18 11:14:13 -03:00
|
|
|
/* optimize null pointers */
|
2001-06-16 05:48:40 -03:00
|
|
|
if (p == NULL)
|
1998-09-18 11:14:13 -03:00
|
|
|
return PyInt_FromLong(0);
|
2003-03-29 06:06:18 -04:00
|
|
|
return PyLong_FromLongLong((PY_LONG_LONG)p);
|
2001-06-16 05:48:40 -03:00
|
|
|
|
|
|
|
#endif /* SIZEOF_VOID_P <= SIZEOF_LONG */
|
1998-09-18 11:14:13 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Get a C pointer from a long object (or an int object in some cases) */
|
|
|
|
|
|
|
|
void *
|
2000-07-07 12:53:28 -03:00
|
|
|
PyLong_AsVoidPtr(PyObject *vv)
|
1998-09-18 11:14:13 -03:00
|
|
|
{
|
|
|
|
/* This function will allow int or long objects. If vv is neither,
|
|
|
|
then the PyLong_AsLong*() functions will raise the exception:
|
|
|
|
PyExc_SystemError, "bad argument to internal function"
|
|
|
|
*/
|
2001-06-16 05:48:40 -03:00
|
|
|
#if SIZEOF_VOID_P <= SIZEOF_LONG
|
1998-09-18 11:14:13 -03:00
|
|
|
long x;
|
|
|
|
|
2001-06-16 05:48:40 -03:00
|
|
|
if (PyInt_Check(vv))
|
1998-09-18 11:14:13 -03:00
|
|
|
x = PyInt_AS_LONG(vv);
|
|
|
|
else
|
|
|
|
x = PyLong_AsLong(vv);
|
|
|
|
#else
|
2001-06-16 05:48:40 -03:00
|
|
|
|
|
|
|
#ifndef HAVE_LONG_LONG
|
|
|
|
# error "PyLong_AsVoidPtr: sizeof(void*) > sizeof(long), but no long long"
|
|
|
|
#endif
|
|
|
|
#if SIZEOF_LONG_LONG < SIZEOF_VOID_P
|
2003-03-29 06:06:18 -04:00
|
|
|
# error "PyLong_AsVoidPtr: sizeof(PY_LONG_LONG) < sizeof(void*)"
|
2001-06-16 05:48:40 -03:00
|
|
|
#endif
|
2003-03-29 06:06:18 -04:00
|
|
|
PY_LONG_LONG x;
|
1998-09-18 11:14:13 -03:00
|
|
|
|
2001-06-16 05:48:40 -03:00
|
|
|
if (PyInt_Check(vv))
|
1998-09-18 11:14:13 -03:00
|
|
|
x = PyInt_AS_LONG(vv);
|
|
|
|
else
|
|
|
|
x = PyLong_AsLongLong(vv);
|
2001-06-16 05:48:40 -03:00
|
|
|
|
|
|
|
#endif /* SIZEOF_VOID_P <= SIZEOF_LONG */
|
1998-09-18 11:14:13 -03:00
|
|
|
|
|
|
|
if (x == -1 && PyErr_Occurred())
|
|
|
|
return NULL;
|
|
|
|
return (void *)x;
|
|
|
|
}
|
|
|
|
|
1998-08-04 19:46:29 -03:00
|
|
|
#ifdef HAVE_LONG_LONG
|
2001-06-12 21:35:57 -03:00
|
|
|
|
2003-03-29 06:06:18 -04:00
|
|
|
/* Initial PY_LONG_LONG support by Chris Herborth (chrish@qnx.com), later
|
2001-06-12 21:35:57 -03:00
|
|
|
* rewritten to use the newer PyLong_{As,From}ByteArray API.
|
1998-08-04 19:46:29 -03:00
|
|
|
*/
|
|
|
|
|
2001-06-14 15:42:50 -03:00
|
|
|
#define IS_LITTLE_ENDIAN (int)*(unsigned char*)&one
|
2001-06-12 21:35:57 -03:00
|
|
|
|
2003-03-29 06:06:18 -04:00
|
|
|
/* Create a new long int object from a C PY_LONG_LONG int. */
|
1998-08-04 19:46:29 -03:00
|
|
|
|
|
|
|
PyObject *
|
2003-03-29 06:06:18 -04:00
|
|
|
PyLong_FromLongLong(PY_LONG_LONG ival)
|
1998-08-04 19:46:29 -03:00
|
|
|
{
|
2003-03-29 06:06:18 -04:00
|
|
|
PY_LONG_LONG bytes = ival;
|
2001-06-12 21:35:57 -03:00
|
|
|
int one = 1;
|
|
|
|
return _PyLong_FromByteArray(
|
|
|
|
(unsigned char *)&bytes,
|
|
|
|
SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 1);
|
1998-08-04 19:46:29 -03:00
|
|
|
}
|
|
|
|
|
2003-03-29 06:06:18 -04:00
|
|
|
/* Create a new long int object from a C unsigned PY_LONG_LONG int. */
|
2001-06-12 21:35:57 -03:00
|
|
|
|
1998-08-04 19:46:29 -03:00
|
|
|
PyObject *
|
2003-03-29 06:06:18 -04:00
|
|
|
PyLong_FromUnsignedLongLong(unsigned PY_LONG_LONG ival)
|
1998-08-04 19:46:29 -03:00
|
|
|
{
|
2003-03-29 06:06:18 -04:00
|
|
|
unsigned PY_LONG_LONG bytes = ival;
|
2001-06-12 21:35:57 -03:00
|
|
|
int one = 1;
|
|
|
|
return _PyLong_FromByteArray(
|
|
|
|
(unsigned char *)&bytes,
|
|
|
|
SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 0);
|
1998-08-04 19:46:29 -03:00
|
|
|
}
|
|
|
|
|
2003-03-29 06:06:18 -04:00
|
|
|
/* Get a C PY_LONG_LONG int from a long int object.
|
2001-06-12 21:35:57 -03:00
|
|
|
Return -1 and set an error if overflow occurs. */
|
1998-08-04 19:46:29 -03:00
|
|
|
|
2003-03-29 06:06:18 -04:00
|
|
|
PY_LONG_LONG
|
2000-07-07 12:53:28 -03:00
|
|
|
PyLong_AsLongLong(PyObject *vv)
|
1998-08-04 19:46:29 -03:00
|
|
|
{
|
2003-03-29 06:06:18 -04:00
|
|
|
PY_LONG_LONG bytes;
|
2001-06-12 21:35:57 -03:00
|
|
|
int one = 1;
|
|
|
|
int res;
|
|
|
|
|
2001-09-30 02:09:37 -03:00
|
|
|
if (vv == NULL) {
|
|
|
|
PyErr_BadInternalCall();
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (!PyLong_Check(vv)) {
|
2005-03-03 08:26:35 -04:00
|
|
|
PyNumberMethods *nb;
|
|
|
|
PyObject *io;
|
2001-09-30 02:09:37 -03:00
|
|
|
if (PyInt_Check(vv))
|
2003-03-29 06:06:18 -04:00
|
|
|
return (PY_LONG_LONG)PyInt_AsLong(vv);
|
2005-03-03 08:26:35 -04:00
|
|
|
if ((nb = vv->ob_type->tp_as_number) == NULL ||
|
|
|
|
nb->nb_int == NULL) {
|
|
|
|
PyErr_SetString(PyExc_TypeError, "an integer is required");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
io = (*nb->nb_int) (vv);
|
|
|
|
if (io == NULL)
|
|
|
|
return -1;
|
|
|
|
if (PyInt_Check(io)) {
|
|
|
|
bytes = PyInt_AsLong(io);
|
|
|
|
Py_DECREF(io);
|
|
|
|
return bytes;
|
|
|
|
}
|
|
|
|
if (PyLong_Check(io)) {
|
|
|
|
bytes = PyLong_AsLongLong(io);
|
|
|
|
Py_DECREF(io);
|
|
|
|
return bytes;
|
|
|
|
}
|
|
|
|
Py_DECREF(io);
|
|
|
|
PyErr_SetString(PyExc_TypeError, "integer conversion failed");
|
1998-08-04 19:46:29 -03:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2001-06-12 21:35:57 -03:00
|
|
|
res = _PyLong_AsByteArray(
|
|
|
|
(PyLongObject *)vv, (unsigned char *)&bytes,
|
|
|
|
SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 1);
|
1998-08-04 19:46:29 -03:00
|
|
|
|
2003-03-29 06:06:18 -04:00
|
|
|
/* Plan 9 can't handle PY_LONG_LONG in ? : expressions */
|
2002-03-09 08:02:59 -04:00
|
|
|
if (res < 0)
|
2003-03-29 06:06:18 -04:00
|
|
|
return (PY_LONG_LONG)-1;
|
2002-03-09 08:02:59 -04:00
|
|
|
else
|
|
|
|
return bytes;
|
1998-08-04 19:46:29 -03:00
|
|
|
}
|
|
|
|
|
2003-03-29 06:06:18 -04:00
|
|
|
/* Get a C unsigned PY_LONG_LONG int from a long int object.
|
2001-06-12 21:35:57 -03:00
|
|
|
Return -1 and set an error if overflow occurs. */
|
|
|
|
|
2003-03-29 06:06:18 -04:00
|
|
|
unsigned PY_LONG_LONG
|
2000-07-07 12:53:28 -03:00
|
|
|
PyLong_AsUnsignedLongLong(PyObject *vv)
|
1998-08-04 19:46:29 -03:00
|
|
|
{
|
2003-03-29 06:06:18 -04:00
|
|
|
unsigned PY_LONG_LONG bytes;
|
2001-06-12 21:35:57 -03:00
|
|
|
int one = 1;
|
|
|
|
int res;
|
|
|
|
|
1998-08-04 19:46:29 -03:00
|
|
|
if (vv == NULL || !PyLong_Check(vv)) {
|
|
|
|
PyErr_BadInternalCall();
|
2001-06-12 21:35:57 -03:00
|
|
|
return -1;
|
1998-08-04 19:46:29 -03:00
|
|
|
}
|
|
|
|
|
2001-06-12 21:35:57 -03:00
|
|
|
res = _PyLong_AsByteArray(
|
|
|
|
(PyLongObject *)vv, (unsigned char *)&bytes,
|
|
|
|
SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 0);
|
1998-08-04 19:46:29 -03:00
|
|
|
|
2003-03-29 06:06:18 -04:00
|
|
|
/* Plan 9 can't handle PY_LONG_LONG in ? : expressions */
|
2002-03-09 08:02:59 -04:00
|
|
|
if (res < 0)
|
2003-03-29 06:06:18 -04:00
|
|
|
return (unsigned PY_LONG_LONG)res;
|
2002-03-09 08:02:59 -04:00
|
|
|
else
|
|
|
|
return bytes;
|
2001-06-12 21:35:57 -03:00
|
|
|
}
|
1998-08-04 19:46:29 -03:00
|
|
|
|
2003-04-17 15:55:45 -03:00
|
|
|
/* Get a C unsigned long int from a long int object, ignoring the high bits.
|
|
|
|
Returns -1 and sets an error condition if an error occurs. */
|
|
|
|
|
|
|
|
unsigned PY_LONG_LONG
|
|
|
|
PyLong_AsUnsignedLongLongMask(PyObject *vv)
|
|
|
|
{
|
|
|
|
register PyLongObject *v;
|
|
|
|
unsigned PY_LONG_LONG x;
|
|
|
|
int i, sign;
|
|
|
|
|
|
|
|
if (vv == NULL || !PyLong_Check(vv)) {
|
|
|
|
PyErr_BadInternalCall();
|
|
|
|
return (unsigned long) -1;
|
|
|
|
}
|
|
|
|
v = (PyLongObject *)vv;
|
|
|
|
i = v->ob_size;
|
|
|
|
sign = 1;
|
|
|
|
x = 0;
|
|
|
|
if (i < 0) {
|
|
|
|
sign = -1;
|
|
|
|
i = -i;
|
|
|
|
}
|
|
|
|
while (--i >= 0) {
|
|
|
|
x = (x << SHIFT) + v->ob_digit[i];
|
|
|
|
}
|
|
|
|
return x * sign;
|
|
|
|
}
|
2001-06-12 21:35:57 -03:00
|
|
|
#undef IS_LITTLE_ENDIAN
|
1998-08-04 19:46:29 -03:00
|
|
|
|
|
|
|
#endif /* HAVE_LONG_LONG */
|
|
|
|
|
2001-01-03 21:46:03 -04:00
|
|
|
|
|
|
|
static int
|
|
|
|
convert_binop(PyObject *v, PyObject *w, PyLongObject **a, PyLongObject **b) {
|
2002-08-11 23:31:19 -03:00
|
|
|
if (PyLong_Check(v)) {
|
2001-01-03 21:46:03 -04:00
|
|
|
*a = (PyLongObject *) v;
|
|
|
|
Py_INCREF(v);
|
|
|
|
}
|
|
|
|
else if (PyInt_Check(v)) {
|
|
|
|
*a = (PyLongObject *) PyLong_FromLong(PyInt_AS_LONG(v));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return 0;
|
|
|
|
}
|
2002-08-11 23:31:19 -03:00
|
|
|
if (PyLong_Check(w)) {
|
2001-01-03 21:46:03 -04:00
|
|
|
*b = (PyLongObject *) w;
|
|
|
|
Py_INCREF(w);
|
|
|
|
}
|
|
|
|
else if (PyInt_Check(w)) {
|
|
|
|
*b = (PyLongObject *) PyLong_FromLong(PyInt_AS_LONG(w));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
Py_DECREF(*a);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define CONVERT_BINOP(v, w, a, b) \
|
|
|
|
if (!convert_binop(v, w, a, b)) { \
|
|
|
|
Py_INCREF(Py_NotImplemented); \
|
|
|
|
return Py_NotImplemented; \
|
|
|
|
}
|
|
|
|
|
2002-08-12 02:09:36 -03:00
|
|
|
/* x[0:m] and y[0:n] are digit vectors, LSD first, m >= n required. x[0:n]
|
|
|
|
* is modified in place, by adding y to it. Carries are propagated as far as
|
|
|
|
* x[m-1], and the remaining carry (0 or 1) is returned.
|
|
|
|
*/
|
|
|
|
static digit
|
|
|
|
v_iadd(digit *x, int m, digit *y, int n)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
digit carry = 0;
|
|
|
|
|
|
|
|
assert(m >= n);
|
|
|
|
for (i = 0; i < n; ++i) {
|
|
|
|
carry += x[i] + y[i];
|
|
|
|
x[i] = carry & MASK;
|
|
|
|
carry >>= SHIFT;
|
|
|
|
assert((carry & 1) == carry);
|
|
|
|
}
|
|
|
|
for (; carry && i < m; ++i) {
|
|
|
|
carry += x[i];
|
|
|
|
x[i] = carry & MASK;
|
|
|
|
carry >>= SHIFT;
|
|
|
|
assert((carry & 1) == carry);
|
|
|
|
}
|
|
|
|
return carry;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* x[0:m] and y[0:n] are digit vectors, LSD first, m >= n required. x[0:n]
|
|
|
|
* is modified in place, by subtracting y from it. Borrows are propagated as
|
|
|
|
* far as x[m-1], and the remaining borrow (0 or 1) is returned.
|
|
|
|
*/
|
|
|
|
static digit
|
|
|
|
v_isub(digit *x, int m, digit *y, int n)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
digit borrow = 0;
|
|
|
|
|
|
|
|
assert(m >= n);
|
|
|
|
for (i = 0; i < n; ++i) {
|
|
|
|
borrow = x[i] - y[i] - borrow;
|
|
|
|
x[i] = borrow & MASK;
|
|
|
|
borrow >>= SHIFT;
|
|
|
|
borrow &= 1; /* keep only 1 sign bit */
|
|
|
|
}
|
|
|
|
for (; borrow && i < m; ++i) {
|
|
|
|
borrow = x[i] - borrow;
|
|
|
|
x[i] = borrow & MASK;
|
|
|
|
borrow >>= SHIFT;
|
|
|
|
borrow &= 1;
|
|
|
|
}
|
|
|
|
return borrow;
|
|
|
|
}
|
2001-01-03 21:46:03 -04:00
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
/* Multiply by a single digit, ignoring the sign. */
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyLongObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
mul1(PyLongObject *a, wdigit n)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
|
|
|
return muladd1(a, n, (digit)0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Multiply by a single digit and add a single digit, ignoring the sign. */
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyLongObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
muladd1(PyLongObject *a, wdigit n, wdigit extra)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
1992-01-14 14:36:43 -04:00
|
|
|
int size_a = ABS(a->ob_size);
|
1997-05-02 00:12:38 -03:00
|
|
|
PyLongObject *z = _PyLong_New(size_a+1);
|
1991-05-05 17:09:44 -03:00
|
|
|
twodigits carry = extra;
|
|
|
|
int i;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
if (z == NULL)
|
|
|
|
return NULL;
|
|
|
|
for (i = 0; i < size_a; ++i) {
|
|
|
|
carry += (twodigits)a->ob_digit[i] * n;
|
1997-04-09 16:41:24 -03:00
|
|
|
z->ob_digit[i] = (digit) (carry & MASK);
|
1991-05-05 17:09:44 -03:00
|
|
|
carry >>= SHIFT;
|
|
|
|
}
|
1997-04-09 16:41:24 -03:00
|
|
|
z->ob_digit[i] = (digit) carry;
|
1991-05-05 17:09:44 -03:00
|
|
|
return long_normalize(z);
|
|
|
|
}
|
|
|
|
|
2001-07-14 09:23:19 -03:00
|
|
|
/* Divide long pin, w/ size digits, by non-zero digit n, storing quotient
|
|
|
|
in pout, and returning the remainder. pin and pout point at the LSD.
|
|
|
|
It's OK for pin == pout on entry, which saves oodles of mallocs/frees in
|
|
|
|
long_format, but that should be done with great care since longs are
|
|
|
|
immutable. */
|
|
|
|
|
|
|
|
static digit
|
|
|
|
inplace_divrem1(digit *pout, digit *pin, int size, digit n)
|
|
|
|
{
|
|
|
|
twodigits rem = 0;
|
|
|
|
|
|
|
|
assert(n > 0 && n <= MASK);
|
|
|
|
pin += size;
|
|
|
|
pout += size;
|
|
|
|
while (--size >= 0) {
|
|
|
|
digit hi;
|
|
|
|
rem = (rem << SHIFT) + *--pin;
|
|
|
|
*--pout = hi = (digit)(rem / n);
|
|
|
|
rem -= hi * n;
|
|
|
|
}
|
|
|
|
return (digit)rem;
|
|
|
|
}
|
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
/* Divide a long integer by a digit, returning both the quotient
|
|
|
|
(as function result) and the remainder (through *prem).
|
|
|
|
The sign of a is ignored; n should not be zero. */
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyLongObject *
|
2001-07-14 09:23:19 -03:00
|
|
|
divrem1(PyLongObject *a, digit n, digit *prem)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
2001-07-14 09:23:19 -03:00
|
|
|
const int size = ABS(a->ob_size);
|
1997-05-02 00:12:38 -03:00
|
|
|
PyLongObject *z;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
assert(n > 0 && n <= MASK);
|
1997-05-02 00:12:38 -03:00
|
|
|
z = _PyLong_New(size);
|
1991-05-05 17:09:44 -03:00
|
|
|
if (z == NULL)
|
|
|
|
return NULL;
|
2001-07-14 09:23:19 -03:00
|
|
|
*prem = inplace_divrem1(z->ob_digit, a->ob_digit, size, n);
|
1991-05-05 17:09:44 -03:00
|
|
|
return long_normalize(z);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Convert a long int object to a string, using a given conversion base.
|
1991-10-24 11:55:57 -03:00
|
|
|
Return a string object.
|
1999-12-23 11:41:28 -04:00
|
|
|
If base is 8 or 16, add the proper prefix '0' or '0x'. */
|
1991-05-05 17:09:44 -03:00
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
long_format(PyObject *aa, int base, int addL)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
1997-05-02 00:12:38 -03:00
|
|
|
register PyLongObject *a = (PyLongObject *)aa;
|
|
|
|
PyStringObject *str;
|
1991-05-05 17:09:44 -03:00
|
|
|
int i;
|
2001-07-14 09:23:19 -03:00
|
|
|
const int size_a = ABS(a->ob_size);
|
1991-05-05 17:09:44 -03:00
|
|
|
char *p;
|
|
|
|
int bits;
|
|
|
|
char sign = '\0';
|
1992-01-19 12:31:05 -04:00
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
if (a == NULL || !PyLong_Check(a)) {
|
|
|
|
PyErr_BadInternalCall();
|
1992-01-19 12:31:05 -04:00
|
|
|
return NULL;
|
|
|
|
}
|
1991-05-05 17:09:44 -03:00
|
|
|
assert(base >= 2 && base <= 36);
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
/* Compute a rough upper bound for the length of the string */
|
|
|
|
i = base;
|
|
|
|
bits = 0;
|
|
|
|
while (i > 1) {
|
|
|
|
++bits;
|
|
|
|
i >>= 1;
|
|
|
|
}
|
1999-12-23 11:41:28 -04:00
|
|
|
i = 5 + (addL ? 1 : 0) + (size_a*SHIFT + bits-1) / bits;
|
1997-05-02 00:12:38 -03:00
|
|
|
str = (PyStringObject *) PyString_FromStringAndSize((char *)0, i);
|
1991-05-05 17:09:44 -03:00
|
|
|
if (str == NULL)
|
|
|
|
return NULL;
|
1997-05-02 00:12:38 -03:00
|
|
|
p = PyString_AS_STRING(str) + i;
|
1991-05-05 17:09:44 -03:00
|
|
|
*p = '\0';
|
1999-12-23 11:41:28 -04:00
|
|
|
if (addL)
|
|
|
|
*--p = 'L';
|
1992-01-14 14:36:43 -04:00
|
|
|
if (a->ob_size < 0)
|
|
|
|
sign = '-';
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1998-08-11 12:04:47 -03:00
|
|
|
if (a->ob_size == 0) {
|
|
|
|
*--p = '0';
|
|
|
|
}
|
|
|
|
else if ((base & (base - 1)) == 0) {
|
|
|
|
/* JRH: special case for power-of-2 bases */
|
2001-07-15 06:11:14 -03:00
|
|
|
twodigits accum = 0;
|
|
|
|
int accumbits = 0; /* # of bits in accum */
|
|
|
|
int basebits = 1; /* # of bits in base-1 */
|
1998-08-11 12:04:47 -03:00
|
|
|
i = base;
|
2000-07-08 01:17:21 -03:00
|
|
|
while ((i >>= 1) > 1)
|
|
|
|
++basebits;
|
2001-07-15 06:11:14 -03:00
|
|
|
|
|
|
|
for (i = 0; i < size_a; ++i) {
|
2002-08-20 16:00:22 -03:00
|
|
|
accum |= (twodigits)a->ob_digit[i] << accumbits;
|
2001-07-15 06:11:14 -03:00
|
|
|
accumbits += SHIFT;
|
|
|
|
assert(accumbits >= basebits);
|
|
|
|
do {
|
2002-02-16 19:39:10 -04:00
|
|
|
char cdigit = (char)(accum & (base - 1));
|
|
|
|
cdigit += (cdigit < 10) ? '0' : 'A'-10;
|
1998-08-11 12:04:47 -03:00
|
|
|
assert(p > PyString_AS_STRING(str));
|
2002-02-16 19:39:10 -04:00
|
|
|
*--p = cdigit;
|
2001-07-15 06:11:14 -03:00
|
|
|
accumbits -= basebits;
|
|
|
|
accum >>= basebits;
|
|
|
|
} while (i < size_a-1 ? accumbits >= basebits :
|
|
|
|
accum > 0);
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
1998-08-11 12:04:47 -03:00
|
|
|
}
|
|
|
|
else {
|
2001-07-12 23:59:26 -03:00
|
|
|
/* Not 0, and base not a power of 2. Divide repeatedly by
|
|
|
|
base, but for speed use the highest power of base that
|
|
|
|
fits in a digit. */
|
2001-07-14 09:23:19 -03:00
|
|
|
int size = size_a;
|
|
|
|
digit *pin = a->ob_digit;
|
|
|
|
PyLongObject *scratch;
|
|
|
|
/* powbasw <- largest power of base that fits in a digit. */
|
2001-07-12 23:59:26 -03:00
|
|
|
digit powbase = base; /* powbase == base ** power */
|
|
|
|
int power = 1;
|
|
|
|
for (;;) {
|
|
|
|
unsigned long newpow = powbase * (unsigned long)base;
|
|
|
|
if (newpow >> SHIFT) /* doesn't fit in a digit */
|
|
|
|
break;
|
|
|
|
powbase = (digit)newpow;
|
|
|
|
++power;
|
|
|
|
}
|
2001-07-14 09:23:19 -03:00
|
|
|
|
|
|
|
/* Get a scratch area for repeated division. */
|
|
|
|
scratch = _PyLong_New(size);
|
|
|
|
if (scratch == NULL) {
|
|
|
|
Py_DECREF(str);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Repeatedly divide by powbase. */
|
1998-08-11 12:04:47 -03:00
|
|
|
do {
|
2001-07-12 23:59:26 -03:00
|
|
|
int ntostore = power;
|
2001-07-14 09:23:19 -03:00
|
|
|
digit rem = inplace_divrem1(scratch->ob_digit,
|
|
|
|
pin, size, powbase);
|
|
|
|
pin = scratch->ob_digit; /* no need to use a again */
|
|
|
|
if (pin[size - 1] == 0)
|
|
|
|
--size;
|
1998-08-11 12:04:47 -03:00
|
|
|
SIGCHECK({
|
2001-07-14 09:23:19 -03:00
|
|
|
Py_DECREF(scratch);
|
1998-08-11 12:04:47 -03:00
|
|
|
Py_DECREF(str);
|
|
|
|
return NULL;
|
|
|
|
})
|
2001-07-14 09:23:19 -03:00
|
|
|
|
|
|
|
/* Break rem into digits. */
|
2001-07-14 08:01:28 -03:00
|
|
|
assert(ntostore > 0);
|
|
|
|
do {
|
2001-07-12 23:59:26 -03:00
|
|
|
digit nextrem = (digit)(rem / base);
|
|
|
|
char c = (char)(rem - nextrem * base);
|
|
|
|
assert(p > PyString_AS_STRING(str));
|
|
|
|
c += (c < 10) ? '0' : 'A'-10;
|
|
|
|
*--p = c;
|
|
|
|
rem = nextrem;
|
2001-07-14 08:01:28 -03:00
|
|
|
--ntostore;
|
|
|
|
/* Termination is a bit delicate: must not
|
|
|
|
store leading zeroes, so must get out if
|
2001-07-14 09:23:19 -03:00
|
|
|
remaining quotient and rem are both 0. */
|
|
|
|
} while (ntostore && (size || rem));
|
|
|
|
} while (size != 0);
|
|
|
|
Py_DECREF(scratch);
|
1998-08-11 12:04:47 -03:00
|
|
|
}
|
|
|
|
|
1992-08-14 12:13:07 -03:00
|
|
|
if (base == 8) {
|
|
|
|
if (size_a != 0)
|
|
|
|
*--p = '0';
|
|
|
|
}
|
1991-10-24 11:55:57 -03:00
|
|
|
else if (base == 16) {
|
|
|
|
*--p = 'x';
|
|
|
|
*--p = '0';
|
|
|
|
}
|
1991-11-19 16:26:46 -04:00
|
|
|
else if (base != 10) {
|
|
|
|
*--p = '#';
|
|
|
|
*--p = '0' + base%10;
|
|
|
|
if (base > 10)
|
|
|
|
*--p = '0' + base/10;
|
|
|
|
}
|
1991-05-05 17:09:44 -03:00
|
|
|
if (sign)
|
|
|
|
*--p = sign;
|
1997-05-02 00:12:38 -03:00
|
|
|
if (p != PyString_AS_STRING(str)) {
|
|
|
|
char *q = PyString_AS_STRING(str);
|
1991-05-05 17:09:44 -03:00
|
|
|
assert(p > q);
|
|
|
|
do {
|
|
|
|
} while ((*q++ = *p++) != '\0');
|
1991-05-28 18:58:16 -03:00
|
|
|
q--;
|
1997-05-02 00:12:38 -03:00
|
|
|
_PyString_Resize((PyObject **)&str,
|
|
|
|
(int) (q - PyString_AS_STRING(str)));
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
return (PyObject *)str;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
|
2003-02-02 03:51:32 -04:00
|
|
|
/* *str points to the first digit in a string of base base digits. base
|
|
|
|
* is a power of 2 (2, 4, 8, 16, or 32). *str is set to point to the first
|
|
|
|
* non-digit (which may be *str!). A normalized long is returned.
|
|
|
|
* The point to this routine is that it takes time linear in the number of
|
|
|
|
* string characters.
|
|
|
|
*/
|
|
|
|
static PyLongObject *
|
|
|
|
long_from_binary_base(char **str, int base)
|
|
|
|
{
|
|
|
|
char *p = *str;
|
|
|
|
char *start = p;
|
|
|
|
int bits_per_char;
|
|
|
|
int n;
|
|
|
|
PyLongObject *z;
|
|
|
|
twodigits accum;
|
|
|
|
int bits_in_accum;
|
|
|
|
digit *pdigit;
|
|
|
|
|
|
|
|
assert(base >= 2 && base <= 32 && (base & (base - 1)) == 0);
|
|
|
|
n = base;
|
|
|
|
for (bits_per_char = -1; n; ++bits_per_char)
|
|
|
|
n >>= 1;
|
|
|
|
/* n <- total # of bits needed, while setting p to end-of-string */
|
|
|
|
n = 0;
|
|
|
|
for (;;) {
|
|
|
|
int k = -1;
|
|
|
|
char ch = *p;
|
|
|
|
|
|
|
|
if (ch <= '9')
|
|
|
|
k = ch - '0';
|
|
|
|
else if (ch >= 'a')
|
|
|
|
k = ch - 'a' + 10;
|
|
|
|
else if (ch >= 'A')
|
|
|
|
k = ch - 'A' + 10;
|
|
|
|
if (k < 0 || k >= base)
|
|
|
|
break;
|
|
|
|
++p;
|
|
|
|
}
|
|
|
|
*str = p;
|
2003-02-02 13:33:53 -04:00
|
|
|
n = (p - start) * bits_per_char;
|
|
|
|
if (n / bits_per_char != p - start) {
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"long string too large to convert");
|
|
|
|
return NULL;
|
|
|
|
}
|
2003-02-02 03:51:32 -04:00
|
|
|
/* n <- # of Python digits needed, = ceiling(n/SHIFT). */
|
|
|
|
n = (n + SHIFT - 1) / SHIFT;
|
|
|
|
z = _PyLong_New(n);
|
|
|
|
if (z == NULL)
|
|
|
|
return NULL;
|
|
|
|
/* Read string from right, and fill in long from left; i.e.,
|
|
|
|
* from least to most significant in both.
|
|
|
|
*/
|
|
|
|
accum = 0;
|
|
|
|
bits_in_accum = 0;
|
|
|
|
pdigit = z->ob_digit;
|
|
|
|
while (--p >= start) {
|
2003-05-05 17:39:43 -03:00
|
|
|
int k;
|
|
|
|
char ch = *p;
|
2003-02-02 03:51:32 -04:00
|
|
|
|
|
|
|
if (ch <= '9')
|
|
|
|
k = ch - '0';
|
|
|
|
else if (ch >= 'a')
|
|
|
|
k = ch - 'a' + 10;
|
|
|
|
else {
|
|
|
|
assert(ch >= 'A');
|
|
|
|
k = ch - 'A' + 10;
|
|
|
|
}
|
2003-05-05 17:39:43 -03:00
|
|
|
assert(k >= 0 && k < base);
|
|
|
|
accum |= (twodigits)(k << bits_in_accum);
|
2003-02-02 03:51:32 -04:00
|
|
|
bits_in_accum += bits_per_char;
|
|
|
|
if (bits_in_accum >= SHIFT) {
|
|
|
|
*pdigit++ = (digit)(accum & MASK);
|
|
|
|
assert(pdigit - z->ob_digit <= n);
|
|
|
|
accum >>= SHIFT;
|
|
|
|
bits_in_accum -= SHIFT;
|
|
|
|
assert(bits_in_accum < SHIFT);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (bits_in_accum) {
|
|
|
|
assert(bits_in_accum <= SHIFT);
|
|
|
|
*pdigit++ = (digit)accum;
|
|
|
|
assert(pdigit - z->ob_digit <= n);
|
|
|
|
}
|
|
|
|
while (pdigit - z->ob_digit < n)
|
|
|
|
*pdigit++ = 0;
|
|
|
|
return long_normalize(z);
|
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
PyObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
PyLong_FromString(char *str, char **pend, int base)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
|
|
|
int sign = 1;
|
2000-04-05 17:11:21 -03:00
|
|
|
char *start, *orig_str = str;
|
1997-05-02 00:12:38 -03:00
|
|
|
PyLongObject *z;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1996-12-05 17:57:21 -04:00
|
|
|
if ((base != 0 && base < 2) || base > 36) {
|
1997-05-02 00:12:38 -03:00
|
|
|
PyErr_SetString(PyExc_ValueError,
|
2000-10-24 16:57:45 -03:00
|
|
|
"long() arg 2 must be >= 2 and <= 36");
|
1994-08-29 09:47:19 -03:00
|
|
|
return NULL;
|
|
|
|
}
|
1995-02-10 13:00:37 -04:00
|
|
|
while (*str != '\0' && isspace(Py_CHARMASK(*str)))
|
1994-08-29 09:47:19 -03:00
|
|
|
str++;
|
1991-05-05 17:09:44 -03:00
|
|
|
if (*str == '+')
|
|
|
|
++str;
|
|
|
|
else if (*str == '-') {
|
|
|
|
++str;
|
|
|
|
sign = -1;
|
|
|
|
}
|
1995-02-10 13:00:37 -04:00
|
|
|
while (*str != '\0' && isspace(Py_CHARMASK(*str)))
|
1994-08-29 09:47:19 -03:00
|
|
|
str++;
|
1991-05-05 17:09:44 -03:00
|
|
|
if (base == 0) {
|
|
|
|
if (str[0] != '0')
|
|
|
|
base = 10;
|
|
|
|
else if (str[1] == 'x' || str[1] == 'X')
|
|
|
|
base = 16;
|
|
|
|
else
|
|
|
|
base = 8;
|
|
|
|
}
|
|
|
|
if (base == 16 && str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
|
|
|
|
str += 2;
|
1998-06-22 00:54:46 -03:00
|
|
|
start = str;
|
2003-02-02 03:51:32 -04:00
|
|
|
if ((base & (base - 1)) == 0)
|
|
|
|
z = long_from_binary_base(&str, base);
|
|
|
|
else {
|
|
|
|
z = _PyLong_New(0);
|
|
|
|
for ( ; z != NULL; ++str) {
|
|
|
|
int k = -1;
|
|
|
|
PyLongObject *temp;
|
|
|
|
|
|
|
|
if (*str <= '9')
|
|
|
|
k = *str - '0';
|
|
|
|
else if (*str >= 'a')
|
|
|
|
k = *str - 'a' + 10;
|
|
|
|
else if (*str >= 'A')
|
|
|
|
k = *str - 'A' + 10;
|
|
|
|
if (k < 0 || k >= base)
|
|
|
|
break;
|
|
|
|
temp = muladd1(z, (digit)base, (digit)k);
|
|
|
|
Py_DECREF(z);
|
|
|
|
z = temp;
|
|
|
|
}
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
1998-08-04 12:04:06 -03:00
|
|
|
if (z == NULL)
|
|
|
|
return NULL;
|
2000-04-05 17:11:21 -03:00
|
|
|
if (str == start)
|
|
|
|
goto onError;
|
1991-11-19 16:26:46 -04:00
|
|
|
if (sign < 0 && z != NULL && z->ob_size != 0)
|
1992-01-14 14:36:43 -04:00
|
|
|
z->ob_size = -(z->ob_size);
|
2000-04-05 17:11:21 -03:00
|
|
|
if (*str == 'L' || *str == 'l')
|
|
|
|
str++;
|
|
|
|
while (*str && isspace(Py_CHARMASK(*str)))
|
|
|
|
str++;
|
|
|
|
if (*str != '\0')
|
|
|
|
goto onError;
|
1994-08-29 09:47:19 -03:00
|
|
|
if (pend)
|
|
|
|
*pend = str;
|
1997-05-02 00:12:38 -03:00
|
|
|
return (PyObject *) z;
|
2000-04-05 17:11:21 -03:00
|
|
|
|
|
|
|
onError:
|
2002-08-11 23:31:19 -03:00
|
|
|
PyErr_Format(PyExc_ValueError,
|
2000-04-05 17:11:21 -03:00
|
|
|
"invalid literal for long(): %.200s", orig_str);
|
|
|
|
Py_XDECREF(z);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2001-08-17 15:39:25 -03:00
|
|
|
#ifdef Py_USING_UNICODE
|
2000-04-05 17:11:21 -03:00
|
|
|
PyObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
PyLong_FromUnicode(Py_UNICODE *u, int length, int base)
|
2000-04-05 17:11:21 -03:00
|
|
|
{
|
2002-11-06 12:15:14 -04:00
|
|
|
PyObject *result;
|
|
|
|
char *buffer = PyMem_MALLOC(length+1);
|
2000-04-05 17:11:21 -03:00
|
|
|
|
2002-11-06 12:15:14 -04:00
|
|
|
if (buffer == NULL)
|
2000-04-05 17:11:21 -03:00
|
|
|
return NULL;
|
|
|
|
|
2002-11-06 12:15:14 -04:00
|
|
|
if (PyUnicode_EncodeDecimal(u, length, buffer, NULL)) {
|
|
|
|
PyMem_FREE(buffer);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
result = PyLong_FromString(buffer, NULL, base);
|
|
|
|
PyMem_FREE(buffer);
|
|
|
|
return result;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
2001-08-17 15:39:25 -03:00
|
|
|
#endif
|
1991-05-05 17:09:44 -03:00
|
|
|
|
2000-07-07 12:53:28 -03:00
|
|
|
/* forward */
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyLongObject *x_divrem
|
2000-07-07 12:53:28 -03:00
|
|
|
(PyLongObject *, PyLongObject *, PyLongObject **);
|
|
|
|
static PyObject *long_pos(PyLongObject *);
|
|
|
|
static int long_divrem(PyLongObject *, PyLongObject *,
|
|
|
|
PyLongObject **, PyLongObject **);
|
1991-05-05 17:09:44 -03:00
|
|
|
|
|
|
|
/* Long division with remainder, top-level routine */
|
|
|
|
|
1992-01-19 12:31:05 -04:00
|
|
|
static int
|
2000-07-07 12:53:28 -03:00
|
|
|
long_divrem(PyLongObject *a, PyLongObject *b,
|
|
|
|
PyLongObject **pdiv, PyLongObject **prem)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
1992-01-14 14:36:43 -04:00
|
|
|
int size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
|
1997-05-02 00:12:38 -03:00
|
|
|
PyLongObject *z;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
if (size_b == 0) {
|
1998-08-11 12:04:47 -03:00
|
|
|
PyErr_SetString(PyExc_ZeroDivisionError,
|
2000-10-24 16:57:45 -03:00
|
|
|
"long division or modulo by zero");
|
1992-01-19 12:31:05 -04:00
|
|
|
return -1;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
if (size_a < size_b ||
|
1996-12-05 17:57:21 -04:00
|
|
|
(size_a == size_b &&
|
|
|
|
a->ob_digit[size_a-1] < b->ob_digit[size_b-1])) {
|
1991-05-05 17:09:44 -03:00
|
|
|
/* |a| < |b|. */
|
1997-05-02 00:12:38 -03:00
|
|
|
*pdiv = _PyLong_New(0);
|
|
|
|
Py_INCREF(a);
|
|
|
|
*prem = (PyLongObject *) a;
|
1992-01-19 12:31:05 -04:00
|
|
|
return 0;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
if (size_b == 1) {
|
|
|
|
digit rem = 0;
|
|
|
|
z = divrem1(a, b->ob_digit[0], &rem);
|
1992-01-19 12:31:05 -04:00
|
|
|
if (z == NULL)
|
|
|
|
return -1;
|
1997-05-02 00:12:38 -03:00
|
|
|
*prem = (PyLongObject *) PyLong_FromLong((long)rem);
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
1992-01-19 12:31:05 -04:00
|
|
|
else {
|
1991-05-05 17:09:44 -03:00
|
|
|
z = x_divrem(a, b, prem);
|
1992-01-19 12:31:05 -04:00
|
|
|
if (z == NULL)
|
|
|
|
return -1;
|
|
|
|
}
|
1991-05-05 17:09:44 -03:00
|
|
|
/* Set the signs.
|
|
|
|
The quotient z has the sign of a*b;
|
|
|
|
the remainder r has the sign of a,
|
|
|
|
so a = b*z + r. */
|
1992-01-19 12:31:05 -04:00
|
|
|
if ((a->ob_size < 0) != (b->ob_size < 0))
|
|
|
|
z->ob_size = -(z->ob_size);
|
|
|
|
if (a->ob_size < 0 && (*prem)->ob_size != 0)
|
|
|
|
(*prem)->ob_size = -((*prem)->ob_size);
|
|
|
|
*pdiv = z;
|
|
|
|
return 0;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
|
1991-05-14 09:06:49 -03:00
|
|
|
/* Unsigned long division with remainder -- the algorithm */
|
1991-05-05 17:09:44 -03:00
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyLongObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
1992-01-14 14:36:43 -04:00
|
|
|
int size_v = ABS(v1->ob_size), size_w = ABS(w1->ob_size);
|
1997-04-09 16:41:24 -03:00
|
|
|
digit d = (digit) ((twodigits)BASE / (w1->ob_digit[size_w-1] + 1));
|
1997-05-02 00:12:38 -03:00
|
|
|
PyLongObject *v = mul1(v1, d);
|
|
|
|
PyLongObject *w = mul1(w1, d);
|
|
|
|
PyLongObject *a;
|
1991-05-05 17:09:44 -03:00
|
|
|
int j, k;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
if (v == NULL || w == NULL) {
|
1997-05-02 00:12:38 -03:00
|
|
|
Py_XDECREF(v);
|
|
|
|
Py_XDECREF(w);
|
1991-05-05 17:09:44 -03:00
|
|
|
return NULL;
|
|
|
|
}
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
assert(size_v >= size_w && size_w > 1); /* Assert checks by div() */
|
1991-05-14 09:06:49 -03:00
|
|
|
assert(v->ob_refcnt == 1); /* Since v will be used as accumulator! */
|
1992-01-14 14:36:43 -04:00
|
|
|
assert(size_w == ABS(w->ob_size)); /* That's how d was calculated */
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1992-01-14 14:36:43 -04:00
|
|
|
size_v = ABS(v->ob_size);
|
1997-05-02 00:12:38 -03:00
|
|
|
a = _PyLong_New(size_v - size_w + 1);
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
for (j = size_v, k = a->ob_size-1; a != NULL && k >= 0; --j, --k) {
|
|
|
|
digit vj = (j >= size_v) ? 0 : v->ob_digit[j];
|
|
|
|
twodigits q;
|
1991-05-14 09:06:49 -03:00
|
|
|
stwodigits carry = 0;
|
1991-05-05 17:09:44 -03:00
|
|
|
int i;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1994-08-29 09:47:19 -03:00
|
|
|
SIGCHECK({
|
1997-05-02 00:12:38 -03:00
|
|
|
Py_DECREF(a);
|
1991-05-05 17:09:44 -03:00
|
|
|
a = NULL;
|
|
|
|
break;
|
1991-05-14 09:06:49 -03:00
|
|
|
})
|
1991-05-05 17:09:44 -03:00
|
|
|
if (vj == w->ob_digit[size_w-1])
|
|
|
|
q = MASK;
|
|
|
|
else
|
|
|
|
q = (((twodigits)vj << SHIFT) + v->ob_digit[j-1]) /
|
|
|
|
w->ob_digit[size_w-1];
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
while (w->ob_digit[size_w-2]*q >
|
|
|
|
((
|
|
|
|
((twodigits)vj << SHIFT)
|
|
|
|
+ v->ob_digit[j-1]
|
|
|
|
- q*w->ob_digit[size_w-1]
|
|
|
|
) << SHIFT)
|
|
|
|
+ v->ob_digit[j-2])
|
|
|
|
--q;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
for (i = 0; i < size_w && i+k < size_v; ++i) {
|
|
|
|
twodigits z = w->ob_digit[i] * q;
|
1997-04-09 16:41:24 -03:00
|
|
|
digit zz = (digit) (z >> SHIFT);
|
1997-05-02 00:12:38 -03:00
|
|
|
carry += v->ob_digit[i+k] - z
|
|
|
|
+ ((twodigits)zz << SHIFT);
|
2003-05-01 18:31:53 -03:00
|
|
|
v->ob_digit[i+k] = (digit)(carry & MASK);
|
2000-07-08 01:17:21 -03:00
|
|
|
carry = Py_ARITHMETIC_RIGHT_SHIFT(BASE_TWODIGITS_TYPE,
|
|
|
|
carry, SHIFT);
|
|
|
|
carry -= zz;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
if (i+k < size_v) {
|
|
|
|
carry += v->ob_digit[i+k];
|
|
|
|
v->ob_digit[i+k] = 0;
|
|
|
|
}
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
if (carry == 0)
|
1997-04-09 16:41:24 -03:00
|
|
|
a->ob_digit[k] = (digit) q;
|
1991-05-05 17:09:44 -03:00
|
|
|
else {
|
|
|
|
assert(carry == -1);
|
1997-04-09 16:41:24 -03:00
|
|
|
a->ob_digit[k] = (digit) q-1;
|
1991-05-05 17:09:44 -03:00
|
|
|
carry = 0;
|
|
|
|
for (i = 0; i < size_w && i+k < size_v; ++i) {
|
|
|
|
carry += v->ob_digit[i+k] + w->ob_digit[i];
|
2003-05-01 18:31:53 -03:00
|
|
|
v->ob_digit[i+k] = (digit)(carry & MASK);
|
2000-07-08 01:17:21 -03:00
|
|
|
carry = Py_ARITHMETIC_RIGHT_SHIFT(
|
|
|
|
BASE_TWODIGITS_TYPE,
|
|
|
|
carry, SHIFT);
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} /* for j, k */
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1995-01-10 11:23:19 -04:00
|
|
|
if (a == NULL)
|
|
|
|
*prem = NULL;
|
|
|
|
else {
|
1991-11-19 16:26:46 -04:00
|
|
|
a = long_normalize(a);
|
1992-01-19 12:31:05 -04:00
|
|
|
*prem = divrem1(v, d, &d);
|
|
|
|
/* d receives the (unused) remainder */
|
|
|
|
if (*prem == NULL) {
|
1997-05-02 00:12:38 -03:00
|
|
|
Py_DECREF(a);
|
1992-01-19 12:31:05 -04:00
|
|
|
a = NULL;
|
1991-11-19 16:26:46 -04:00
|
|
|
}
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
Py_DECREF(v);
|
|
|
|
Py_DECREF(w);
|
1991-05-05 17:09:44 -03:00
|
|
|
return a;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Methods */
|
|
|
|
|
|
|
|
static void
|
2000-07-07 12:53:28 -03:00
|
|
|
long_dealloc(PyObject *v)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
2001-10-05 17:51:39 -03:00
|
|
|
v->ob_type->tp_free(v);
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
long_repr(PyObject *v)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
1999-12-23 11:41:28 -04:00
|
|
|
return long_format(v, 10, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
long_str(PyObject *v)
|
1999-12-23 11:41:28 -04:00
|
|
|
{
|
|
|
|
return long_format(v, 10, 0);
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2000-07-07 12:53:28 -03:00
|
|
|
long_compare(PyLongObject *a, PyLongObject *b)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
|
|
|
int sign;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1991-11-19 16:26:46 -04:00
|
|
|
if (a->ob_size != b->ob_size) {
|
1992-01-14 14:36:43 -04:00
|
|
|
if (ABS(a->ob_size) == 0 && ABS(b->ob_size) == 0)
|
1991-11-19 16:26:46 -04:00
|
|
|
sign = 0;
|
|
|
|
else
|
|
|
|
sign = a->ob_size - b->ob_size;
|
|
|
|
}
|
1991-05-05 17:09:44 -03:00
|
|
|
else {
|
1992-01-14 14:36:43 -04:00
|
|
|
int i = ABS(a->ob_size);
|
1991-05-05 17:09:44 -03:00
|
|
|
while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i])
|
|
|
|
;
|
|
|
|
if (i < 0)
|
|
|
|
sign = 0;
|
1993-01-21 12:07:51 -04:00
|
|
|
else {
|
1991-05-05 17:09:44 -03:00
|
|
|
sign = (int)a->ob_digit[i] - (int)b->ob_digit[i];
|
1993-01-21 12:07:51 -04:00
|
|
|
if (a->ob_size < 0)
|
|
|
|
sign = -sign;
|
|
|
|
}
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
1991-11-19 16:26:46 -04:00
|
|
|
return sign < 0 ? -1 : sign > 0 ? 1 : 0;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
|
1993-03-29 06:43:31 -04:00
|
|
|
static long
|
2000-07-07 12:53:28 -03:00
|
|
|
long_hash(PyLongObject *v)
|
1993-03-29 06:43:31 -04:00
|
|
|
{
|
|
|
|
long x;
|
|
|
|
int i, sign;
|
|
|
|
|
|
|
|
/* This is designed so that Python ints and longs with the
|
|
|
|
same value hash to the same value, otherwise comparisons
|
|
|
|
of mapping keys will turn out weird */
|
|
|
|
i = v->ob_size;
|
|
|
|
sign = 1;
|
|
|
|
x = 0;
|
|
|
|
if (i < 0) {
|
|
|
|
sign = -1;
|
|
|
|
i = -(i);
|
|
|
|
}
|
2003-02-23 19:11:41 -04:00
|
|
|
#define LONG_BIT_SHIFT (8*sizeof(long) - SHIFT)
|
1993-03-29 06:43:31 -04:00
|
|
|
while (--i >= 0) {
|
2003-02-23 19:11:41 -04:00
|
|
|
/* Force a native long #-bits (32 or 64) circular shift */
|
|
|
|
x = ((x << SHIFT) & ~MASK) | ((x >> LONG_BIT_SHIFT) & MASK);
|
1993-03-29 06:43:31 -04:00
|
|
|
x += v->ob_digit[i];
|
|
|
|
}
|
2003-02-23 19:11:41 -04:00
|
|
|
#undef LONG_BIT_SHIFT
|
1993-03-29 06:43:31 -04:00
|
|
|
x = x * sign;
|
|
|
|
if (x == -1)
|
|
|
|
x = -2;
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
/* Add the absolute values of two long integers. */
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyLongObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
x_add(PyLongObject *a, PyLongObject *b)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
1992-01-14 14:36:43 -04:00
|
|
|
int size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
|
1997-05-02 00:12:38 -03:00
|
|
|
PyLongObject *z;
|
1991-05-05 17:09:44 -03:00
|
|
|
int i;
|
|
|
|
digit carry = 0;
|
2001-09-11 19:31:33 -03:00
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
/* Ensure a is the larger of the two: */
|
|
|
|
if (size_a < size_b) {
|
1997-05-02 00:12:38 -03:00
|
|
|
{ PyLongObject *temp = a; a = b; b = temp; }
|
|
|
|
{ int size_temp = size_a;
|
|
|
|
size_a = size_b;
|
|
|
|
size_b = size_temp; }
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
z = _PyLong_New(size_a+1);
|
1991-05-05 17:09:44 -03:00
|
|
|
if (z == NULL)
|
|
|
|
return NULL;
|
|
|
|
for (i = 0; i < size_b; ++i) {
|
|
|
|
carry += a->ob_digit[i] + b->ob_digit[i];
|
|
|
|
z->ob_digit[i] = carry & MASK;
|
|
|
|
carry >>= SHIFT;
|
|
|
|
}
|
|
|
|
for (; i < size_a; ++i) {
|
|
|
|
carry += a->ob_digit[i];
|
|
|
|
z->ob_digit[i] = carry & MASK;
|
|
|
|
carry >>= SHIFT;
|
|
|
|
}
|
|
|
|
z->ob_digit[i] = carry;
|
|
|
|
return long_normalize(z);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Subtract the absolute values of two integers. */
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyLongObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
x_sub(PyLongObject *a, PyLongObject *b)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
1992-01-14 14:36:43 -04:00
|
|
|
int size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
|
1997-05-02 00:12:38 -03:00
|
|
|
PyLongObject *z;
|
1991-05-05 17:09:44 -03:00
|
|
|
int i;
|
|
|
|
int sign = 1;
|
|
|
|
digit borrow = 0;
|
2001-09-11 19:31:33 -03:00
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
/* Ensure a is the larger of the two: */
|
|
|
|
if (size_a < size_b) {
|
|
|
|
sign = -1;
|
1997-05-02 00:12:38 -03:00
|
|
|
{ PyLongObject *temp = a; a = b; b = temp; }
|
|
|
|
{ int size_temp = size_a;
|
|
|
|
size_a = size_b;
|
|
|
|
size_b = size_temp; }
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
else if (size_a == size_b) {
|
|
|
|
/* Find highest digit where a and b differ: */
|
|
|
|
i = size_a;
|
|
|
|
while (--i >= 0 && a->ob_digit[i] == b->ob_digit[i])
|
|
|
|
;
|
|
|
|
if (i < 0)
|
1997-05-02 00:12:38 -03:00
|
|
|
return _PyLong_New(0);
|
1991-05-05 17:09:44 -03:00
|
|
|
if (a->ob_digit[i] < b->ob_digit[i]) {
|
|
|
|
sign = -1;
|
1997-05-02 00:12:38 -03:00
|
|
|
{ PyLongObject *temp = a; a = b; b = temp; }
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
size_a = size_b = i+1;
|
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
z = _PyLong_New(size_a);
|
1991-05-05 17:09:44 -03:00
|
|
|
if (z == NULL)
|
|
|
|
return NULL;
|
|
|
|
for (i = 0; i < size_b; ++i) {
|
|
|
|
/* The following assumes unsigned arithmetic
|
|
|
|
works module 2**N for some N>SHIFT. */
|
1994-08-29 09:47:19 -03:00
|
|
|
borrow = a->ob_digit[i] - b->ob_digit[i] - borrow;
|
1991-05-05 17:09:44 -03:00
|
|
|
z->ob_digit[i] = borrow & MASK;
|
|
|
|
borrow >>= SHIFT;
|
|
|
|
borrow &= 1; /* Keep only one sign bit */
|
|
|
|
}
|
|
|
|
for (; i < size_a; ++i) {
|
|
|
|
borrow = a->ob_digit[i] - borrow;
|
|
|
|
z->ob_digit[i] = borrow & MASK;
|
|
|
|
borrow >>= SHIFT;
|
2000-07-07 23:26:47 -03:00
|
|
|
borrow &= 1; /* Keep only one sign bit */
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
assert(borrow == 0);
|
1991-11-19 16:26:46 -04:00
|
|
|
if (sign < 0)
|
1992-01-14 14:36:43 -04:00
|
|
|
z->ob_size = -(z->ob_size);
|
1991-05-05 17:09:44 -03:00
|
|
|
return long_normalize(z);
|
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2001-01-03 21:46:03 -04:00
|
|
|
long_add(PyLongObject *v, PyLongObject *w)
|
1992-01-14 14:36:43 -04:00
|
|
|
{
|
2001-01-03 21:46:03 -04:00
|
|
|
PyLongObject *a, *b, *z;
|
2001-09-11 19:31:33 -03:00
|
|
|
|
2001-01-03 21:46:03 -04:00
|
|
|
CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b);
|
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
if (a->ob_size < 0) {
|
|
|
|
if (b->ob_size < 0) {
|
|
|
|
z = x_add(a, b);
|
1991-11-19 16:26:46 -04:00
|
|
|
if (z != NULL && z->ob_size != 0)
|
1992-01-14 14:36:43 -04:00
|
|
|
z->ob_size = -(z->ob_size);
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
z = x_sub(b, a);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (b->ob_size < 0)
|
|
|
|
z = x_sub(a, b);
|
|
|
|
else
|
|
|
|
z = x_add(a, b);
|
|
|
|
}
|
2001-01-03 21:46:03 -04:00
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
1997-05-02 00:12:38 -03:00
|
|
|
return (PyObject *)z;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2001-01-03 21:46:03 -04:00
|
|
|
long_sub(PyLongObject *v, PyLongObject *w)
|
1992-01-14 14:36:43 -04:00
|
|
|
{
|
2001-01-03 21:46:03 -04:00
|
|
|
PyLongObject *a, *b, *z;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
2001-01-03 21:46:03 -04:00
|
|
|
CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b);
|
|
|
|
|
1991-05-05 17:09:44 -03:00
|
|
|
if (a->ob_size < 0) {
|
|
|
|
if (b->ob_size < 0)
|
|
|
|
z = x_sub(a, b);
|
|
|
|
else
|
|
|
|
z = x_add(a, b);
|
1991-11-19 16:26:46 -04:00
|
|
|
if (z != NULL && z->ob_size != 0)
|
1992-01-14 14:36:43 -04:00
|
|
|
z->ob_size = -(z->ob_size);
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (b->ob_size < 0)
|
|
|
|
z = x_add(a, b);
|
|
|
|
else
|
|
|
|
z = x_sub(a, b);
|
|
|
|
}
|
2001-01-03 21:46:03 -04:00
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
1997-05-02 00:12:38 -03:00
|
|
|
return (PyObject *)z;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
|
2002-08-11 23:31:19 -03:00
|
|
|
/* Grade school multiplication, ignoring the signs.
|
|
|
|
* Returns the absolute value of the product, or NULL if error.
|
|
|
|
*/
|
|
|
|
static PyLongObject *
|
|
|
|
x_mul(PyLongObject *a, PyLongObject *b)
|
2001-01-03 21:46:03 -04:00
|
|
|
{
|
2002-08-11 23:31:19 -03:00
|
|
|
PyLongObject *z;
|
|
|
|
int size_a = ABS(a->ob_size);
|
|
|
|
int size_b = ABS(b->ob_size);
|
1991-05-05 17:09:44 -03:00
|
|
|
int i;
|
2001-01-03 21:46:03 -04:00
|
|
|
|
2002-08-11 23:31:19 -03:00
|
|
|
z = _PyLong_New(size_a + size_b);
|
|
|
|
if (z == NULL)
|
1991-05-05 17:09:44 -03:00
|
|
|
return NULL;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
|
|
|
memset(z->ob_digit, 0, z->ob_size * sizeof(digit));
|
2004-08-29 19:16:50 -03:00
|
|
|
if (a == b) {
|
|
|
|
/* Efficient squaring per HAC, Algorithm 14.16:
|
|
|
|
* http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf
|
|
|
|
* Gives slightly less than a 2x speedup when a == b,
|
|
|
|
* via exploiting that each entry in the multiplication
|
|
|
|
* pyramid appears twice (except for the size_a squares).
|
|
|
|
*/
|
|
|
|
for (i = 0; i < size_a; ++i) {
|
|
|
|
twodigits carry;
|
|
|
|
twodigits f = a->ob_digit[i];
|
|
|
|
digit *pz = z->ob_digit + (i << 1);
|
|
|
|
digit *pa = a->ob_digit + i + 1;
|
|
|
|
digit *paend = a->ob_digit + size_a;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
2004-08-29 19:16:50 -03:00
|
|
|
SIGCHECK({
|
|
|
|
Py_DECREF(z);
|
|
|
|
return NULL;
|
|
|
|
})
|
|
|
|
|
|
|
|
carry = *pz + f * f;
|
|
|
|
*pz++ = (digit)(carry & MASK);
|
1991-05-05 17:09:44 -03:00
|
|
|
carry >>= SHIFT;
|
2004-08-29 19:16:50 -03:00
|
|
|
assert(carry <= MASK);
|
|
|
|
|
|
|
|
/* Now f is added in twice in each column of the
|
|
|
|
* pyramid it appears. Same as adding f<<1 once.
|
|
|
|
*/
|
|
|
|
f <<= 1;
|
|
|
|
while (pa < paend) {
|
|
|
|
carry += *pz + *pa++ * f;
|
|
|
|
*pz++ = (digit)(carry & MASK);
|
|
|
|
carry >>= SHIFT;
|
|
|
|
assert(carry <= (MASK << 1));
|
|
|
|
}
|
|
|
|
if (carry) {
|
|
|
|
carry += *pz;
|
|
|
|
*pz++ = (digit)(carry & MASK);
|
|
|
|
carry >>= SHIFT;
|
|
|
|
}
|
|
|
|
if (carry)
|
|
|
|
*pz += (digit)(carry & MASK);
|
|
|
|
assert((carry >> SHIFT) == 0);
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
2004-08-29 19:16:50 -03:00
|
|
|
}
|
|
|
|
else { /* a is not the same as b -- gradeschool long mult */
|
|
|
|
for (i = 0; i < size_a; ++i) {
|
|
|
|
twodigits carry = 0;
|
|
|
|
twodigits f = a->ob_digit[i];
|
|
|
|
digit *pz = z->ob_digit + i;
|
|
|
|
digit *pb = b->ob_digit;
|
|
|
|
digit *pbend = b->ob_digit + size_b;
|
|
|
|
|
|
|
|
SIGCHECK({
|
|
|
|
Py_DECREF(z);
|
|
|
|
return NULL;
|
|
|
|
})
|
|
|
|
|
|
|
|
while (pb < pbend) {
|
|
|
|
carry += *pz + *pb++ * f;
|
|
|
|
*pz++ = (digit)(carry & MASK);
|
|
|
|
carry >>= SHIFT;
|
|
|
|
assert(carry <= MASK);
|
|
|
|
}
|
|
|
|
if (carry)
|
|
|
|
*pz += (digit)(carry & MASK);
|
|
|
|
assert((carry >> SHIFT) == 0);
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
}
|
x_mul(): This failed to normalize its result.
k_mul(): This didn't allocate enough result space when one input had
more than twice as many bits as the other. This was partly hidden by
that x_mul() didn't normalize its result.
The Karatsuba recurrence is pretty much hosed if the inputs aren't
roughly the same size. If one has at least twice as many bits as the
other, we get a degenerate case where the "high half" of the smaller
input is 0. Added a special case for that, for speed, but despite that
it helped, this can still be much slower than the "grade school" method.
It seems to take a really wild imbalance to trigger that; e.g., a
2**22-bit input times a 1000-bit input on my box runs about twice as slow
under k_mul than under x_mul. This still needs to be addressed.
I'm also not sure that allocating a->ob_size + b->ob_size digits is
enough, given that this is computing k = (ah+al)*(bh+bl) instead of
k = (ah-al)*(bl-bh); i.e., it's certainly enough for the final result,
but it's vaguely possible that adding in the "artificially" large k may
overflow that temporarily. If so, an assert will trigger in the debug
build, but we'll probably compute the right result anyway(!).
2002-08-12 03:17:58 -03:00
|
|
|
return long_normalize(z);
|
2002-08-11 23:31:19 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* A helper for Karatsuba multiplication (k_mul).
|
|
|
|
Takes a long "n" and an integer "size" representing the place to
|
|
|
|
split, and sets low and high such that abs(n) == (high << size) + low,
|
|
|
|
viewing the shift as being by digits. The sign bit is ignored, and
|
|
|
|
the return values are >= 0.
|
|
|
|
Returns 0 on success, -1 on failure.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
kmul_split(PyLongObject *n, int size, PyLongObject **high, PyLongObject **low)
|
|
|
|
{
|
|
|
|
PyLongObject *hi, *lo;
|
|
|
|
int size_lo, size_hi;
|
|
|
|
const int size_n = ABS(n->ob_size);
|
|
|
|
|
|
|
|
size_lo = MIN(size_n, size);
|
|
|
|
size_hi = size_n - size_lo;
|
|
|
|
|
|
|
|
if ((hi = _PyLong_New(size_hi)) == NULL)
|
|
|
|
return -1;
|
|
|
|
if ((lo = _PyLong_New(size_lo)) == NULL) {
|
|
|
|
Py_DECREF(hi);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(lo->ob_digit, n->ob_digit, size_lo * sizeof(digit));
|
|
|
|
memcpy(hi->ob_digit, n->ob_digit + size_lo, size_hi * sizeof(digit));
|
|
|
|
|
|
|
|
*high = long_normalize(hi);
|
|
|
|
*low = long_normalize(lo);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2002-08-12 19:01:34 -03:00
|
|
|
static PyLongObject *k_lopsided_mul(PyLongObject *a, PyLongObject *b);
|
|
|
|
|
2002-08-11 23:31:19 -03:00
|
|
|
/* Karatsuba multiplication. Ignores the input signs, and returns the
|
|
|
|
* absolute value of the product (or NULL if error).
|
|
|
|
* See Knuth Vol. 2 Chapter 4.3.3 (Pp. 294-295).
|
|
|
|
*/
|
|
|
|
static PyLongObject *
|
|
|
|
k_mul(PyLongObject *a, PyLongObject *b)
|
|
|
|
{
|
2002-08-12 12:08:20 -03:00
|
|
|
int asize = ABS(a->ob_size);
|
|
|
|
int bsize = ABS(b->ob_size);
|
2002-08-11 23:31:19 -03:00
|
|
|
PyLongObject *ah = NULL;
|
|
|
|
PyLongObject *al = NULL;
|
|
|
|
PyLongObject *bh = NULL;
|
|
|
|
PyLongObject *bl = NULL;
|
|
|
|
PyLongObject *ret = NULL;
|
2002-08-12 12:08:20 -03:00
|
|
|
PyLongObject *t1, *t2, *t3;
|
2002-08-11 23:31:19 -03:00
|
|
|
int shift; /* the number of digits we split off */
|
|
|
|
int i;
|
2002-08-12 12:08:20 -03:00
|
|
|
|
2002-08-11 23:31:19 -03:00
|
|
|
/* (ah*X+al)(bh*X+bl) = ah*bh*X*X + (ah*bl + al*bh)*X + al*bl
|
|
|
|
* Let k = (ah+al)*(bh+bl) = ah*bl + al*bh + ah*bh + al*bl
|
|
|
|
* Then the original product is
|
2002-08-11 23:43:58 -03:00
|
|
|
* ah*bh*X*X + (k - ah*bh - al*bl)*X + al*bl
|
2002-08-11 23:31:19 -03:00
|
|
|
* By picking X to be a power of 2, "*X" is just shifting, and it's
|
|
|
|
* been reduced to 3 multiplies on numbers half the size.
|
|
|
|
*/
|
|
|
|
|
2002-08-11 23:54:10 -03:00
|
|
|
/* We want to split based on the larger number; fiddle so that b
|
2002-08-11 23:31:19 -03:00
|
|
|
* is largest.
|
|
|
|
*/
|
2002-08-12 12:08:20 -03:00
|
|
|
if (asize > bsize) {
|
2002-08-11 23:31:19 -03:00
|
|
|
t1 = a;
|
|
|
|
a = b;
|
|
|
|
b = t1;
|
2002-08-12 12:08:20 -03:00
|
|
|
|
|
|
|
i = asize;
|
|
|
|
asize = bsize;
|
|
|
|
bsize = i;
|
2002-08-11 23:31:19 -03:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Use gradeschool math when either number is too small. */
|
2004-08-29 19:16:50 -03:00
|
|
|
i = a == b ? KARATSUBA_SQUARE_CUTOFF : KARATSUBA_CUTOFF;
|
|
|
|
if (asize <= i) {
|
2002-08-12 12:08:20 -03:00
|
|
|
if (asize == 0)
|
x_mul(): This failed to normalize its result.
k_mul(): This didn't allocate enough result space when one input had
more than twice as many bits as the other. This was partly hidden by
that x_mul() didn't normalize its result.
The Karatsuba recurrence is pretty much hosed if the inputs aren't
roughly the same size. If one has at least twice as many bits as the
other, we get a degenerate case where the "high half" of the smaller
input is 0. Added a special case for that, for speed, but despite that
it helped, this can still be much slower than the "grade school" method.
It seems to take a really wild imbalance to trigger that; e.g., a
2**22-bit input times a 1000-bit input on my box runs about twice as slow
under k_mul than under x_mul. This still needs to be addressed.
I'm also not sure that allocating a->ob_size + b->ob_size digits is
enough, given that this is computing k = (ah+al)*(bh+bl) instead of
k = (ah-al)*(bl-bh); i.e., it's certainly enough for the final result,
but it's vaguely possible that adding in the "artificially" large k may
overflow that temporarily. If so, an assert will trigger in the debug
build, but we'll probably compute the right result anyway(!).
2002-08-12 03:17:58 -03:00
|
|
|
return _PyLong_New(0);
|
|
|
|
else
|
|
|
|
return x_mul(a, b);
|
|
|
|
}
|
2002-08-11 23:31:19 -03:00
|
|
|
|
2002-08-12 19:01:34 -03:00
|
|
|
/* If a is small compared to b, splitting on b gives a degenerate
|
|
|
|
* case with ah==0, and Karatsuba may be (even much) less efficient
|
|
|
|
* than "grade school" then. However, we can still win, by viewing
|
|
|
|
* b as a string of "big digits", each of width a->ob_size. That
|
|
|
|
* leads to a sequence of balanced calls to k_mul.
|
|
|
|
*/
|
|
|
|
if (2 * asize <= bsize)
|
|
|
|
return k_lopsided_mul(a, b);
|
|
|
|
|
2002-08-13 17:37:51 -03:00
|
|
|
/* Split a & b into hi & lo pieces. */
|
2002-08-12 12:08:20 -03:00
|
|
|
shift = bsize >> 1;
|
2002-08-11 23:31:19 -03:00
|
|
|
if (kmul_split(a, shift, &ah, &al) < 0) goto fail;
|
2002-08-13 17:37:51 -03:00
|
|
|
assert(ah->ob_size > 0); /* the split isn't degenerate */
|
|
|
|
|
2004-08-29 19:16:50 -03:00
|
|
|
if (a == b) {
|
|
|
|
bh = ah;
|
|
|
|
bl = al;
|
|
|
|
Py_INCREF(bh);
|
|
|
|
Py_INCREF(bl);
|
|
|
|
}
|
|
|
|
else if (kmul_split(b, shift, &bh, &bl) < 0) goto fail;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
2002-08-12 14:36:03 -03:00
|
|
|
/* The plan:
|
|
|
|
* 1. Allocate result space (asize + bsize digits: that's always
|
|
|
|
* enough).
|
|
|
|
* 2. Compute ah*bh, and copy into result at 2*shift.
|
|
|
|
* 3. Compute al*bl, and copy into result at 0. Note that this
|
|
|
|
* can't overlap with #2.
|
|
|
|
* 4. Subtract al*bl from the result, starting at shift. This may
|
|
|
|
* underflow (borrow out of the high digit), but we don't care:
|
|
|
|
* we're effectively doing unsigned arithmetic mod
|
|
|
|
* BASE**(sizea + sizeb), and so long as the *final* result fits,
|
|
|
|
* borrows and carries out of the high digit can be ignored.
|
|
|
|
* 5. Subtract ah*bh from the result, starting at shift.
|
|
|
|
* 6. Compute (ah+al)*(bh+bl), and add it into the result starting
|
|
|
|
* at shift.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* 1. Allocate result space. */
|
2002-08-12 16:38:01 -03:00
|
|
|
ret = _PyLong_New(asize + bsize);
|
2002-08-11 23:31:19 -03:00
|
|
|
if (ret == NULL) goto fail;
|
|
|
|
#ifdef Py_DEBUG
|
|
|
|
/* Fill with trash, to catch reference to uninitialized digits. */
|
|
|
|
memset(ret->ob_digit, 0xDF, ret->ob_size * sizeof(digit));
|
|
|
|
#endif
|
x_mul(): This failed to normalize its result.
k_mul(): This didn't allocate enough result space when one input had
more than twice as many bits as the other. This was partly hidden by
that x_mul() didn't normalize its result.
The Karatsuba recurrence is pretty much hosed if the inputs aren't
roughly the same size. If one has at least twice as many bits as the
other, we get a degenerate case where the "high half" of the smaller
input is 0. Added a special case for that, for speed, but despite that
it helped, this can still be much slower than the "grade school" method.
It seems to take a really wild imbalance to trigger that; e.g., a
2**22-bit input times a 1000-bit input on my box runs about twice as slow
under k_mul than under x_mul. This still needs to be addressed.
I'm also not sure that allocating a->ob_size + b->ob_size digits is
enough, given that this is computing k = (ah+al)*(bh+bl) instead of
k = (ah-al)*(bl-bh); i.e., it's certainly enough for the final result,
but it's vaguely possible that adding in the "artificially" large k may
overflow that temporarily. If so, an assert will trigger in the debug
build, but we'll probably compute the right result anyway(!).
2002-08-12 03:17:58 -03:00
|
|
|
|
2002-08-12 14:36:03 -03:00
|
|
|
/* 2. t1 <- ah*bh, and copy into high digits of result. */
|
2002-08-12 12:08:20 -03:00
|
|
|
if ((t1 = k_mul(ah, bh)) == NULL) goto fail;
|
|
|
|
assert(t1->ob_size >= 0);
|
|
|
|
assert(2*shift + t1->ob_size <= ret->ob_size);
|
|
|
|
memcpy(ret->ob_digit + 2*shift, t1->ob_digit,
|
|
|
|
t1->ob_size * sizeof(digit));
|
|
|
|
|
|
|
|
/* Zero-out the digits higher than the ah*bh copy. */
|
|
|
|
i = ret->ob_size - 2*shift - t1->ob_size;
|
x_mul(): This failed to normalize its result.
k_mul(): This didn't allocate enough result space when one input had
more than twice as many bits as the other. This was partly hidden by
that x_mul() didn't normalize its result.
The Karatsuba recurrence is pretty much hosed if the inputs aren't
roughly the same size. If one has at least twice as many bits as the
other, we get a degenerate case where the "high half" of the smaller
input is 0. Added a special case for that, for speed, but despite that
it helped, this can still be much slower than the "grade school" method.
It seems to take a really wild imbalance to trigger that; e.g., a
2**22-bit input times a 1000-bit input on my box runs about twice as slow
under k_mul than under x_mul. This still needs to be addressed.
I'm also not sure that allocating a->ob_size + b->ob_size digits is
enough, given that this is computing k = (ah+al)*(bh+bl) instead of
k = (ah-al)*(bl-bh); i.e., it's certainly enough for the final result,
but it's vaguely possible that adding in the "artificially" large k may
overflow that temporarily. If so, an assert will trigger in the debug
build, but we'll probably compute the right result anyway(!).
2002-08-12 03:17:58 -03:00
|
|
|
if (i)
|
2002-08-12 12:08:20 -03:00
|
|
|
memset(ret->ob_digit + 2*shift + t1->ob_size, 0,
|
x_mul(): This failed to normalize its result.
k_mul(): This didn't allocate enough result space when one input had
more than twice as many bits as the other. This was partly hidden by
that x_mul() didn't normalize its result.
The Karatsuba recurrence is pretty much hosed if the inputs aren't
roughly the same size. If one has at least twice as many bits as the
other, we get a degenerate case where the "high half" of the smaller
input is 0. Added a special case for that, for speed, but despite that
it helped, this can still be much slower than the "grade school" method.
It seems to take a really wild imbalance to trigger that; e.g., a
2**22-bit input times a 1000-bit input on my box runs about twice as slow
under k_mul than under x_mul. This still needs to be addressed.
I'm also not sure that allocating a->ob_size + b->ob_size digits is
enough, given that this is computing k = (ah+al)*(bh+bl) instead of
k = (ah-al)*(bl-bh); i.e., it's certainly enough for the final result,
but it's vaguely possible that adding in the "artificially" large k may
overflow that temporarily. If so, an assert will trigger in the debug
build, but we'll probably compute the right result anyway(!).
2002-08-12 03:17:58 -03:00
|
|
|
i * sizeof(digit));
|
2002-08-11 23:31:19 -03:00
|
|
|
|
2002-08-12 14:36:03 -03:00
|
|
|
/* 3. t2 <- al*bl, and copy into the low digits. */
|
2002-08-12 12:08:20 -03:00
|
|
|
if ((t2 = k_mul(al, bl)) == NULL) {
|
|
|
|
Py_DECREF(t1);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
assert(t2->ob_size >= 0);
|
|
|
|
assert(t2->ob_size <= 2*shift); /* no overlap with high digits */
|
|
|
|
memcpy(ret->ob_digit, t2->ob_digit, t2->ob_size * sizeof(digit));
|
2002-08-11 23:31:19 -03:00
|
|
|
|
|
|
|
/* Zero out remaining digits. */
|
2002-08-12 12:08:20 -03:00
|
|
|
i = 2*shift - t2->ob_size; /* number of uninitialized digits */
|
2002-08-11 23:31:19 -03:00
|
|
|
if (i)
|
2002-08-12 12:08:20 -03:00
|
|
|
memset(ret->ob_digit + t2->ob_size, 0, i * sizeof(digit));
|
|
|
|
|
2002-08-12 14:36:03 -03:00
|
|
|
/* 4 & 5. Subtract ah*bh (t1) and al*bl (t2). We do al*bl first
|
|
|
|
* because it's fresher in cache.
|
|
|
|
*/
|
2002-08-12 12:08:20 -03:00
|
|
|
i = ret->ob_size - shift; /* # digits after shift */
|
2002-08-12 14:36:03 -03:00
|
|
|
(void)v_isub(ret->ob_digit + shift, i, t2->ob_digit, t2->ob_size);
|
2002-08-12 12:08:20 -03:00
|
|
|
Py_DECREF(t2);
|
2002-08-11 23:31:19 -03:00
|
|
|
|
2002-08-12 14:36:03 -03:00
|
|
|
(void)v_isub(ret->ob_digit + shift, i, t1->ob_digit, t1->ob_size);
|
2002-08-12 12:08:20 -03:00
|
|
|
Py_DECREF(t1);
|
|
|
|
|
2002-08-12 14:36:03 -03:00
|
|
|
/* 6. t3 <- (ah+al)(bh+bl), and add into result. */
|
2002-08-11 23:31:19 -03:00
|
|
|
if ((t1 = x_add(ah, al)) == NULL) goto fail;
|
|
|
|
Py_DECREF(ah);
|
|
|
|
Py_DECREF(al);
|
|
|
|
ah = al = NULL;
|
|
|
|
|
2004-08-29 19:16:50 -03:00
|
|
|
if (a == b) {
|
|
|
|
t2 = t1;
|
|
|
|
Py_INCREF(t2);
|
|
|
|
}
|
|
|
|
else if ((t2 = x_add(bh, bl)) == NULL) {
|
2002-08-11 23:31:19 -03:00
|
|
|
Py_DECREF(t1);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
Py_DECREF(bh);
|
|
|
|
Py_DECREF(bl);
|
|
|
|
bh = bl = NULL;
|
|
|
|
|
2002-08-12 12:08:20 -03:00
|
|
|
t3 = k_mul(t1, t2);
|
2002-08-11 23:31:19 -03:00
|
|
|
Py_DECREF(t1);
|
|
|
|
Py_DECREF(t2);
|
2002-08-12 12:08:20 -03:00
|
|
|
if (t3 == NULL) goto fail;
|
2002-08-12 16:43:49 -03:00
|
|
|
assert(t3->ob_size >= 0);
|
2002-08-12 02:09:36 -03:00
|
|
|
|
2002-08-13 17:37:51 -03:00
|
|
|
/* Add t3. It's not obvious why we can't run out of room here.
|
|
|
|
* See the (*) comment after this function.
|
2002-08-12 16:30:26 -03:00
|
|
|
*/
|
2002-08-12 14:36:03 -03:00
|
|
|
(void)v_iadd(ret->ob_digit + shift, i, t3->ob_digit, t3->ob_size);
|
2002-08-12 12:08:20 -03:00
|
|
|
Py_DECREF(t3);
|
2002-08-11 23:31:19 -03:00
|
|
|
|
|
|
|
return long_normalize(ret);
|
|
|
|
|
|
|
|
fail:
|
|
|
|
Py_XDECREF(ret);
|
|
|
|
Py_XDECREF(ah);
|
|
|
|
Py_XDECREF(al);
|
|
|
|
Py_XDECREF(bh);
|
|
|
|
Py_XDECREF(bl);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2002-08-13 17:37:51 -03:00
|
|
|
/* (*) Why adding t3 can't "run out of room" above.
|
|
|
|
|
2002-08-15 17:06:00 -03:00
|
|
|
Let f(x) mean the floor of x and c(x) mean the ceiling of x. Some facts
|
|
|
|
to start with:
|
|
|
|
|
|
|
|
1. For any integer i, i = c(i/2) + f(i/2). In particular,
|
|
|
|
bsize = c(bsize/2) + f(bsize/2).
|
|
|
|
2. shift = f(bsize/2)
|
|
|
|
3. asize <= bsize
|
|
|
|
4. Since we call k_lopsided_mul if asize*2 <= bsize, asize*2 > bsize in this
|
|
|
|
routine, so asize > bsize/2 >= f(bsize/2) in this routine.
|
|
|
|
|
|
|
|
We allocated asize + bsize result digits, and add t3 into them at an offset
|
|
|
|
of shift. This leaves asize+bsize-shift allocated digit positions for t3
|
|
|
|
to fit into, = (by #1 and #2) asize + f(bsize/2) + c(bsize/2) - f(bsize/2) =
|
|
|
|
asize + c(bsize/2) available digit positions.
|
|
|
|
|
|
|
|
bh has c(bsize/2) digits, and bl at most f(size/2) digits. So bh+hl has
|
|
|
|
at most c(bsize/2) digits + 1 bit.
|
|
|
|
|
|
|
|
If asize == bsize, ah has c(bsize/2) digits, else ah has at most f(bsize/2)
|
|
|
|
digits, and al has at most f(bsize/2) digits in any case. So ah+al has at
|
|
|
|
most (asize == bsize ? c(bsize/2) : f(bsize/2)) digits + 1 bit.
|
|
|
|
|
|
|
|
The product (ah+al)*(bh+bl) therefore has at most
|
|
|
|
|
|
|
|
c(bsize/2) + (asize == bsize ? c(bsize/2) : f(bsize/2)) digits + 2 bits
|
|
|
|
|
|
|
|
and we have asize + c(bsize/2) available digit positions. We need to show
|
|
|
|
this is always enough. An instance of c(bsize/2) cancels out in both, so
|
|
|
|
the question reduces to whether asize digits is enough to hold
|
|
|
|
(asize == bsize ? c(bsize/2) : f(bsize/2)) digits + 2 bits. If asize < bsize,
|
|
|
|
then we're asking whether asize digits >= f(bsize/2) digits + 2 bits. By #4,
|
|
|
|
asize is at least f(bsize/2)+1 digits, so this in turn reduces to whether 1
|
|
|
|
digit is enough to hold 2 bits. This is so since SHIFT=15 >= 2. If
|
|
|
|
asize == bsize, then we're asking whether bsize digits is enough to hold
|
2002-08-15 17:10:45 -03:00
|
|
|
c(bsize/2) digits + 2 bits, or equivalently (by #1) whether f(bsize/2) digits
|
|
|
|
is enough to hold 2 bits. This is so if bsize >= 2, which holds because
|
|
|
|
bsize >= KARATSUBA_CUTOFF >= 2.
|
2002-08-14 13:36:23 -03:00
|
|
|
|
2002-08-14 14:07:32 -03:00
|
|
|
Note that since there's always enough room for (ah+al)*(bh+bl), and that's
|
|
|
|
clearly >= each of ah*bh and al*bl, there's always enough room to subtract
|
|
|
|
ah*bh and al*bl too.
|
2002-08-13 17:37:51 -03:00
|
|
|
*/
|
|
|
|
|
2002-08-12 19:01:34 -03:00
|
|
|
/* b has at least twice the digits of a, and a is big enough that Karatsuba
|
|
|
|
* would pay off *if* the inputs had balanced sizes. View b as a sequence
|
|
|
|
* of slices, each with a->ob_size digits, and multiply the slices by a,
|
|
|
|
* one at a time. This gives k_mul balanced inputs to work with, and is
|
|
|
|
* also cache-friendly (we compute one double-width slice of the result
|
|
|
|
* at a time, then move on, never bactracking except for the helpful
|
|
|
|
* single-width slice overlap between successive partial sums).
|
|
|
|
*/
|
|
|
|
static PyLongObject *
|
|
|
|
k_lopsided_mul(PyLongObject *a, PyLongObject *b)
|
|
|
|
{
|
|
|
|
const int asize = ABS(a->ob_size);
|
|
|
|
int bsize = ABS(b->ob_size);
|
|
|
|
int nbdone; /* # of b digits already multiplied */
|
|
|
|
PyLongObject *ret;
|
|
|
|
PyLongObject *bslice = NULL;
|
|
|
|
|
|
|
|
assert(asize > KARATSUBA_CUTOFF);
|
|
|
|
assert(2 * asize <= bsize);
|
|
|
|
|
|
|
|
/* Allocate result space, and zero it out. */
|
|
|
|
ret = _PyLong_New(asize + bsize);
|
|
|
|
if (ret == NULL)
|
|
|
|
return NULL;
|
|
|
|
memset(ret->ob_digit, 0, ret->ob_size * sizeof(digit));
|
|
|
|
|
|
|
|
/* Successive slices of b are copied into bslice. */
|
2002-08-12 19:10:00 -03:00
|
|
|
bslice = _PyLong_New(asize);
|
2002-08-12 19:01:34 -03:00
|
|
|
if (bslice == NULL)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
nbdone = 0;
|
|
|
|
while (bsize > 0) {
|
|
|
|
PyLongObject *product;
|
|
|
|
const int nbtouse = MIN(bsize, asize);
|
|
|
|
|
|
|
|
/* Multiply the next slice of b by a. */
|
|
|
|
memcpy(bslice->ob_digit, b->ob_digit + nbdone,
|
|
|
|
nbtouse * sizeof(digit));
|
|
|
|
bslice->ob_size = nbtouse;
|
|
|
|
product = k_mul(a, bslice);
|
|
|
|
if (product == NULL)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
/* Add into result. */
|
|
|
|
(void)v_iadd(ret->ob_digit + nbdone, ret->ob_size - nbdone,
|
|
|
|
product->ob_digit, product->ob_size);
|
|
|
|
Py_DECREF(product);
|
|
|
|
|
|
|
|
bsize -= nbtouse;
|
|
|
|
nbdone += nbtouse;
|
|
|
|
}
|
|
|
|
|
|
|
|
Py_DECREF(bslice);
|
|
|
|
return long_normalize(ret);
|
|
|
|
|
|
|
|
fail:
|
|
|
|
Py_DECREF(ret);
|
|
|
|
Py_XDECREF(bslice);
|
|
|
|
return NULL;
|
|
|
|
}
|
2002-08-11 23:31:19 -03:00
|
|
|
|
|
|
|
static PyObject *
|
|
|
|
long_mul(PyLongObject *v, PyLongObject *w)
|
|
|
|
{
|
|
|
|
PyLongObject *a, *b, *z;
|
|
|
|
|
|
|
|
if (!convert_binop((PyObject *)v, (PyObject *)w, &a, &b)) {
|
|
|
|
Py_INCREF(Py_NotImplemented);
|
|
|
|
return Py_NotImplemented;
|
|
|
|
}
|
|
|
|
|
2002-08-12 14:36:03 -03:00
|
|
|
z = k_mul(a, b);
|
2002-08-15 16:41:06 -03:00
|
|
|
/* Negate if exactly one of the inputs is negative. */
|
|
|
|
if (((a->ob_size ^ b->ob_size) < 0) && z)
|
1992-01-14 14:36:43 -04:00
|
|
|
z->ob_size = -(z->ob_size);
|
2001-01-03 21:46:03 -04:00
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
2002-08-15 16:41:06 -03:00
|
|
|
return (PyObject *)z;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
|
1992-01-19 12:31:05 -04:00
|
|
|
/* The / and % operators are now defined in terms of divmod().
|
|
|
|
The expression a mod b has the value a - b*floor(a/b).
|
|
|
|
The long_divrem function gives the remainder after division of
|
1991-05-05 17:09:44 -03:00
|
|
|
|a| by |b|, with the sign of a. This is also expressed
|
|
|
|
as a - b*trunc(a/b), if trunc truncates towards zero.
|
|
|
|
Some examples:
|
|
|
|
a b a rem b a mod b
|
|
|
|
13 10 3 3
|
|
|
|
-13 10 -3 7
|
|
|
|
13 -10 3 -7
|
|
|
|
-13 -10 -3 -3
|
|
|
|
So, to get from rem to mod, we have to add b if a and b
|
1991-05-14 09:06:49 -03:00
|
|
|
have different signs. We then subtract one from the 'div'
|
|
|
|
part of the outcome to keep the invariant intact. */
|
1991-05-05 17:09:44 -03:00
|
|
|
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
/* Compute
|
|
|
|
* *pdiv, *pmod = divmod(v, w)
|
|
|
|
* NULL can be passed for pdiv or pmod, in which case that part of
|
|
|
|
* the result is simply thrown away. The caller owns a reference to
|
|
|
|
* each of these it requests (does not pass NULL for).
|
|
|
|
*/
|
1992-01-19 12:31:05 -04:00
|
|
|
static int
|
2002-08-11 23:31:19 -03:00
|
|
|
l_divmod(PyLongObject *v, PyLongObject *w,
|
2000-07-07 12:53:28 -03:00
|
|
|
PyLongObject **pdiv, PyLongObject **pmod)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
1997-05-02 00:12:38 -03:00
|
|
|
PyLongObject *div, *mod;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1992-01-19 12:31:05 -04:00
|
|
|
if (long_divrem(v, w, &div, &mod) < 0)
|
|
|
|
return -1;
|
1996-12-05 17:57:21 -04:00
|
|
|
if ((mod->ob_size < 0 && w->ob_size > 0) ||
|
|
|
|
(mod->ob_size > 0 && w->ob_size < 0)) {
|
1997-05-02 00:12:38 -03:00
|
|
|
PyLongObject *temp;
|
|
|
|
PyLongObject *one;
|
|
|
|
temp = (PyLongObject *) long_add(mod, w);
|
|
|
|
Py_DECREF(mod);
|
1992-01-19 12:31:05 -04:00
|
|
|
mod = temp;
|
|
|
|
if (mod == NULL) {
|
1997-05-02 00:12:38 -03:00
|
|
|
Py_DECREF(div);
|
1992-01-19 12:31:05 -04:00
|
|
|
return -1;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
one = (PyLongObject *) PyLong_FromLong(1L);
|
1991-05-14 09:06:49 -03:00
|
|
|
if (one == NULL ||
|
1997-05-02 00:12:38 -03:00
|
|
|
(temp = (PyLongObject *) long_sub(div, one)) == NULL) {
|
|
|
|
Py_DECREF(mod);
|
|
|
|
Py_DECREF(div);
|
|
|
|
Py_XDECREF(one);
|
1992-01-19 12:31:05 -04:00
|
|
|
return -1;
|
1991-05-14 09:06:49 -03:00
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
Py_DECREF(one);
|
|
|
|
Py_DECREF(div);
|
1991-05-14 09:06:49 -03:00
|
|
|
div = temp;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
if (pdiv != NULL)
|
|
|
|
*pdiv = div;
|
|
|
|
else
|
|
|
|
Py_DECREF(div);
|
|
|
|
|
|
|
|
if (pmod != NULL)
|
|
|
|
*pmod = mod;
|
|
|
|
else
|
|
|
|
Py_DECREF(mod);
|
|
|
|
|
1992-01-19 12:31:05 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2001-01-03 21:46:03 -04:00
|
|
|
long_div(PyObject *v, PyObject *w)
|
1992-01-19 12:31:05 -04:00
|
|
|
{
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
PyLongObject *a, *b, *div;
|
2001-01-03 21:46:03 -04:00
|
|
|
|
|
|
|
CONVERT_BINOP(v, w, &a, &b);
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
if (l_divmod(a, b, &div, NULL) < 0)
|
|
|
|
div = NULL;
|
2001-01-03 21:46:03 -04:00
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
1997-05-02 00:12:38 -03:00
|
|
|
return (PyObject *)div;
|
1992-01-19 12:31:05 -04:00
|
|
|
}
|
|
|
|
|
Add warning mode for classic division, almost exactly as specified in
PEP 238. Changes:
- add a new flag variable Py_DivisionWarningFlag, declared in
pydebug.h, defined in object.c, set in main.c, and used in
{int,long,float,complex}object.c. When this flag is set, the
classic division operator issues a DeprecationWarning message.
- add a new API PyRun_SimpleStringFlags() to match
PyRun_SimpleString(). The main() function calls this so that
commands run with -c can also benefit from -Dnew.
- While I was at it, I changed the usage message in main() somewhat:
alphabetized the options, split it in *four* parts to fit in under
512 bytes (not that I still believe this is necessary -- doc strings
elsewhere are much longer), and perhaps most visibly, don't display
the full list of options on each command line error. Instead, the
full list is only displayed when -h is used, and otherwise a brief
reminder of -h is displayed. When -h is used, write to stdout so
that you can do `python -h | more'.
Notes:
- I don't want to use the -W option to control whether the classic
division warning is issued or not, because the machinery to decide
whether to display the warning or not is very expensive (it involves
calling into the warnings.py module). You can use -Werror to turn
the warnings into exceptions though.
- The -Dnew option doesn't select future division for all of the
program -- only for the __main__ module. I don't know if I'll ever
change this -- it would require changes to the .pyc file magic
number to do it right, and a more global notion of compiler flags.
- You can usefully combine -Dwarn and -Dnew: this gives the __main__
module new division, and warns about classic division everywhere
else.
2001-08-31 14:40:15 -03:00
|
|
|
static PyObject *
|
|
|
|
long_classic_div(PyObject *v, PyObject *w)
|
|
|
|
{
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
PyLongObject *a, *b, *div;
|
Add warning mode for classic division, almost exactly as specified in
PEP 238. Changes:
- add a new flag variable Py_DivisionWarningFlag, declared in
pydebug.h, defined in object.c, set in main.c, and used in
{int,long,float,complex}object.c. When this flag is set, the
classic division operator issues a DeprecationWarning message.
- add a new API PyRun_SimpleStringFlags() to match
PyRun_SimpleString(). The main() function calls this so that
commands run with -c can also benefit from -Dnew.
- While I was at it, I changed the usage message in main() somewhat:
alphabetized the options, split it in *four* parts to fit in under
512 bytes (not that I still believe this is necessary -- doc strings
elsewhere are much longer), and perhaps most visibly, don't display
the full list of options on each command line error. Instead, the
full list is only displayed when -h is used, and otherwise a brief
reminder of -h is displayed. When -h is used, write to stdout so
that you can do `python -h | more'.
Notes:
- I don't want to use the -W option to control whether the classic
division warning is issued or not, because the machinery to decide
whether to display the warning or not is very expensive (it involves
calling into the warnings.py module). You can use -Werror to turn
the warnings into exceptions though.
- The -Dnew option doesn't select future division for all of the
program -- only for the __main__ module. I don't know if I'll ever
change this -- it would require changes to the .pyc file magic
number to do it right, and a more global notion of compiler flags.
- You can usefully combine -Dwarn and -Dnew: this gives the __main__
module new division, and warns about classic division everywhere
else.
2001-08-31 14:40:15 -03:00
|
|
|
|
|
|
|
CONVERT_BINOP(v, w, &a, &b);
|
|
|
|
if (Py_DivisionWarningFlag &&
|
|
|
|
PyErr_Warn(PyExc_DeprecationWarning, "classic long division") < 0)
|
|
|
|
div = NULL;
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
else if (l_divmod(a, b, &div, NULL) < 0)
|
Add warning mode for classic division, almost exactly as specified in
PEP 238. Changes:
- add a new flag variable Py_DivisionWarningFlag, declared in
pydebug.h, defined in object.c, set in main.c, and used in
{int,long,float,complex}object.c. When this flag is set, the
classic division operator issues a DeprecationWarning message.
- add a new API PyRun_SimpleStringFlags() to match
PyRun_SimpleString(). The main() function calls this so that
commands run with -c can also benefit from -Dnew.
- While I was at it, I changed the usage message in main() somewhat:
alphabetized the options, split it in *four* parts to fit in under
512 bytes (not that I still believe this is necessary -- doc strings
elsewhere are much longer), and perhaps most visibly, don't display
the full list of options on each command line error. Instead, the
full list is only displayed when -h is used, and otherwise a brief
reminder of -h is displayed. When -h is used, write to stdout so
that you can do `python -h | more'.
Notes:
- I don't want to use the -W option to control whether the classic
division warning is issued or not, because the machinery to decide
whether to display the warning or not is very expensive (it involves
calling into the warnings.py module). You can use -Werror to turn
the warnings into exceptions though.
- The -Dnew option doesn't select future division for all of the
program -- only for the __main__ module. I don't know if I'll ever
change this -- it would require changes to the .pyc file magic
number to do it right, and a more global notion of compiler flags.
- You can usefully combine -Dwarn and -Dnew: this gives the __main__
module new division, and warns about classic division everywhere
else.
2001-08-31 14:40:15 -03:00
|
|
|
div = NULL;
|
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
|
|
|
return (PyObject *)div;
|
|
|
|
}
|
|
|
|
|
2001-09-04 02:31:47 -03:00
|
|
|
static PyObject *
|
|
|
|
long_true_divide(PyObject *v, PyObject *w)
|
|
|
|
{
|
2001-09-04 03:17:36 -03:00
|
|
|
PyLongObject *a, *b;
|
|
|
|
double ad, bd;
|
2001-11-04 19:09:40 -04:00
|
|
|
int aexp, bexp, failed;
|
2001-09-04 03:17:36 -03:00
|
|
|
|
|
|
|
CONVERT_BINOP(v, w, &a, &b);
|
|
|
|
ad = _PyLong_AsScaledDouble((PyObject *)a, &aexp);
|
|
|
|
bd = _PyLong_AsScaledDouble((PyObject *)b, &bexp);
|
2001-11-04 19:09:40 -04:00
|
|
|
failed = (ad == -1.0 || bd == -1.0) && PyErr_Occurred();
|
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
|
|
|
if (failed)
|
2001-09-04 03:17:36 -03:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (bd == 0.0) {
|
|
|
|
PyErr_SetString(PyExc_ZeroDivisionError,
|
|
|
|
"long division or modulo by zero");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* True value is very close to ad/bd * 2**(SHIFT*(aexp-bexp)) */
|
|
|
|
ad /= bd; /* overflow/underflow impossible here */
|
|
|
|
aexp -= bexp;
|
|
|
|
if (aexp > INT_MAX / SHIFT)
|
|
|
|
goto overflow;
|
2001-09-06 18:59:14 -03:00
|
|
|
else if (aexp < -(INT_MAX / SHIFT))
|
|
|
|
return PyFloat_FromDouble(0.0); /* underflow to 0 */
|
2001-09-04 03:17:36 -03:00
|
|
|
errno = 0;
|
|
|
|
ad = ldexp(ad, aexp * SHIFT);
|
2001-09-05 02:38:10 -03:00
|
|
|
if (Py_OVERFLOWED(ad)) /* ignore underflow to 0.0 */
|
2001-09-04 03:17:36 -03:00
|
|
|
goto overflow;
|
|
|
|
return PyFloat_FromDouble(ad);
|
|
|
|
|
|
|
|
overflow:
|
|
|
|
PyErr_SetString(PyExc_OverflowError,
|
|
|
|
"long/long too large for a float");
|
|
|
|
return NULL;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
2001-09-04 02:31:47 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2001-01-03 21:46:03 -04:00
|
|
|
long_mod(PyObject *v, PyObject *w)
|
1992-01-19 12:31:05 -04:00
|
|
|
{
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
PyLongObject *a, *b, *mod;
|
2001-01-03 21:46:03 -04:00
|
|
|
|
|
|
|
CONVERT_BINOP(v, w, &a, &b);
|
|
|
|
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
if (l_divmod(a, b, NULL, &mod) < 0)
|
|
|
|
mod = NULL;
|
2001-01-03 21:46:03 -04:00
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
1997-05-02 00:12:38 -03:00
|
|
|
return (PyObject *)mod;
|
1992-01-19 12:31:05 -04:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2001-01-03 21:46:03 -04:00
|
|
|
long_divmod(PyObject *v, PyObject *w)
|
1992-01-19 12:31:05 -04:00
|
|
|
{
|
2001-01-03 21:46:03 -04:00
|
|
|
PyLongObject *a, *b, *div, *mod;
|
1997-05-02 00:12:38 -03:00
|
|
|
PyObject *z;
|
2001-01-03 21:46:03 -04:00
|
|
|
|
|
|
|
CONVERT_BINOP(v, w, &a, &b);
|
|
|
|
|
|
|
|
if (l_divmod(a, b, &div, &mod) < 0) {
|
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
1992-01-19 12:31:05 -04:00
|
|
|
return NULL;
|
2001-01-03 21:46:03 -04:00
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
z = PyTuple_New(2);
|
1991-05-05 17:09:44 -03:00
|
|
|
if (z != NULL) {
|
1997-05-02 00:12:38 -03:00
|
|
|
PyTuple_SetItem(z, 0, (PyObject *) div);
|
|
|
|
PyTuple_SetItem(z, 1, (PyObject *) mod);
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
else {
|
1997-05-02 00:12:38 -03:00
|
|
|
Py_DECREF(div);
|
|
|
|
Py_DECREF(mod);
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
2001-01-03 21:46:03 -04:00
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
1991-05-05 17:09:44 -03:00
|
|
|
return z;
|
|
|
|
}
|
|
|
|
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
/* pow(v, w, x) */
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2001-01-03 21:46:03 -04:00
|
|
|
long_pow(PyObject *v, PyObject *w, PyObject *x)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
PyLongObject *a, *b, *c; /* a,b,c = v,w,x */
|
|
|
|
int negativeOutput = 0; /* if x<0 return negative output */
|
|
|
|
|
|
|
|
PyLongObject *z = NULL; /* accumulated result */
|
|
|
|
int i, j, k; /* counters */
|
|
|
|
PyLongObject *temp = NULL;
|
2001-01-03 21:46:03 -04:00
|
|
|
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
/* 5-ary values. If the exponent is large enough, table is
|
|
|
|
* precomputed so that table[i] == a**i % c for i in range(32).
|
|
|
|
*/
|
|
|
|
PyLongObject *table[32] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
|
|
|
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
|
|
|
|
|
|
|
|
/* a, b, c = v, w, x */
|
2001-01-03 21:46:03 -04:00
|
|
|
CONVERT_BINOP(v, w, &a, &b);
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
if (PyLong_Check(x)) {
|
|
|
|
c = (PyLongObject *)x;
|
2001-01-03 21:46:03 -04:00
|
|
|
Py_INCREF(x);
|
|
|
|
}
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
else if (PyInt_Check(x))
|
|
|
|
c = (PyLongObject *)PyLong_FromLong(PyInt_AS_LONG(x));
|
|
|
|
else if (x == Py_None)
|
|
|
|
c = NULL;
|
2001-01-03 21:46:03 -04:00
|
|
|
else {
|
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
|
|
|
Py_INCREF(Py_NotImplemented);
|
|
|
|
return Py_NotImplemented;
|
|
|
|
}
|
2001-09-05 03:24:58 -03:00
|
|
|
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
if (b->ob_size < 0) { /* if exponent is negative */
|
|
|
|
if (c) {
|
2001-09-05 03:24:58 -03:00
|
|
|
PyErr_SetString(PyExc_TypeError, "pow() 2nd argument "
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
"cannot be negative when 3rd argument specified");
|
2004-08-29 23:58:59 -03:00
|
|
|
goto Error;
|
2001-09-03 05:35:41 -03:00
|
|
|
}
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
else {
|
|
|
|
/* else return a float. This works because we know
|
|
|
|
that this calls float_pow() which converts its
|
|
|
|
arguments to double. */
|
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
|
|
|
return PyFloat_Type.tp_as_number->nb_power(v, w, x);
|
|
|
|
}
|
1991-05-28 18:58:16 -03:00
|
|
|
}
|
2002-08-11 23:31:19 -03:00
|
|
|
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
if (c) {
|
|
|
|
/* if modulus == 0:
|
|
|
|
raise ValueError() */
|
|
|
|
if (c->ob_size == 0) {
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"pow() 3rd argument cannot be 0");
|
2004-08-29 23:58:59 -03:00
|
|
|
goto Error;
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
}
|
2002-08-11 23:31:19 -03:00
|
|
|
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
/* if modulus < 0:
|
|
|
|
negativeOutput = True
|
|
|
|
modulus = -modulus */
|
|
|
|
if (c->ob_size < 0) {
|
|
|
|
negativeOutput = 1;
|
|
|
|
temp = (PyLongObject *)_PyLong_Copy(c);
|
|
|
|
if (temp == NULL)
|
|
|
|
goto Error;
|
|
|
|
Py_DECREF(c);
|
|
|
|
c = temp;
|
|
|
|
temp = NULL;
|
|
|
|
c->ob_size = - c->ob_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if modulus == 1:
|
|
|
|
return 0 */
|
|
|
|
if ((c->ob_size == 1) && (c->ob_digit[0] == 1)) {
|
|
|
|
z = (PyLongObject *)PyLong_FromLong(0L);
|
|
|
|
goto Done;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if base < 0:
|
|
|
|
base = base % modulus
|
|
|
|
Having the base positive just makes things easier. */
|
|
|
|
if (a->ob_size < 0) {
|
|
|
|
if (l_divmod(a, c, NULL, &temp) < 0)
|
2004-08-29 23:58:59 -03:00
|
|
|
goto Error;
|
1997-05-02 00:12:38 -03:00
|
|
|
Py_DECREF(a);
|
1991-05-28 18:58:16 -03:00
|
|
|
a = temp;
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
temp = NULL;
|
1991-05-28 18:58:16 -03:00
|
|
|
}
|
|
|
|
}
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
|
|
|
|
/* At this point a, b, and c are guaranteed non-negative UNLESS
|
|
|
|
c is NULL, in which case a may be negative. */
|
|
|
|
|
|
|
|
z = (PyLongObject *)PyLong_FromLong(1L);
|
|
|
|
if (z == NULL)
|
|
|
|
goto Error;
|
|
|
|
|
|
|
|
/* Perform a modular reduction, X = X % c, but leave X alone if c
|
|
|
|
* is NULL.
|
|
|
|
*/
|
|
|
|
#define REDUCE(X) \
|
|
|
|
if (c != NULL) { \
|
|
|
|
if (l_divmod(X, c, NULL, &temp) < 0) \
|
|
|
|
goto Error; \
|
|
|
|
Py_XDECREF(X); \
|
|
|
|
X = temp; \
|
|
|
|
temp = NULL; \
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Multiply two values, then reduce the result:
|
|
|
|
result = X*Y % c. If c is NULL, skip the mod. */
|
|
|
|
#define MULT(X, Y, result) \
|
|
|
|
{ \
|
|
|
|
temp = (PyLongObject *)long_mul(X, Y); \
|
|
|
|
if (temp == NULL) \
|
|
|
|
goto Error; \
|
|
|
|
Py_XDECREF(result); \
|
|
|
|
result = temp; \
|
|
|
|
temp = NULL; \
|
|
|
|
REDUCE(result) \
|
|
|
|
}
|
|
|
|
|
|
|
|
if (b->ob_size <= FIVEARY_CUTOFF) {
|
|
|
|
/* Left-to-right binary exponentiation (HAC Algorithm 14.79) */
|
|
|
|
/* http://www.cacr.math.uwaterloo.ca/hac/about/chap14.pdf */
|
|
|
|
for (i = b->ob_size - 1; i >= 0; --i) {
|
|
|
|
digit bi = b->ob_digit[i];
|
|
|
|
|
|
|
|
for (j = 1 << (SHIFT-1); j != 0; j >>= 1) {
|
|
|
|
MULT(z, z, z)
|
|
|
|
if (bi & j)
|
|
|
|
MULT(z, a, z)
|
|
|
|
}
|
1999-10-11 19:34:41 -03:00
|
|
|
}
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* Left-to-right 5-ary exponentiation (HAC Algorithm 14.82) */
|
|
|
|
Py_INCREF(z); /* still holds 1L */
|
|
|
|
table[0] = z;
|
|
|
|
for (i = 1; i < 32; ++i)
|
|
|
|
MULT(table[i-1], a, table[i])
|
|
|
|
|
|
|
|
for (i = b->ob_size - 1; i >= 0; --i) {
|
|
|
|
const digit bi = b->ob_digit[i];
|
|
|
|
|
|
|
|
for (j = SHIFT - 5; j >= 0; j -= 5) {
|
|
|
|
const int index = (bi >> j) & 0x1f;
|
|
|
|
for (k = 0; k < 5; ++k)
|
|
|
|
MULT(z, z, z)
|
|
|
|
if (index)
|
|
|
|
MULT(z, table[index], z)
|
|
|
|
}
|
1999-10-11 19:34:41 -03:00
|
|
|
}
|
1994-08-29 09:47:19 -03:00
|
|
|
}
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
|
|
|
|
if (negativeOutput && (z->ob_size != 0)) {
|
|
|
|
temp = (PyLongObject *)long_sub(z, c);
|
|
|
|
if (temp == NULL)
|
|
|
|
goto Error;
|
|
|
|
Py_DECREF(z);
|
|
|
|
z = temp;
|
|
|
|
temp = NULL;
|
|
|
|
}
|
|
|
|
goto Done;
|
|
|
|
|
|
|
|
Error:
|
|
|
|
if (z != NULL) {
|
|
|
|
Py_DECREF(z);
|
|
|
|
z = NULL;
|
|
|
|
}
|
|
|
|
/* fall through */
|
|
|
|
Done:
|
2001-01-03 21:46:03 -04:00
|
|
|
Py_XDECREF(a);
|
SF patch 936813: fast modular exponentiation
This checkin is adapted from part 2 (of 3) of Trevor Perrin's patch set.
BACKWARD INCOMPATIBILITY: SHIFT must now be divisible by 5. AFAIK,
nobody will care. long_pow() could be complicated to worm around that,
if necessary.
long_pow():
- BUGFIX: This leaked the base and power when the power was negative
(and so the computation delegated to float pow).
- Instead of doing right-to-left exponentiation, do left-to-right. This
is more efficient for small bases, which is the common case.
- In addition, if the exponent is large (more than FIVEARY_CUTOFF
digits), precompute [a**i % c for i in range(32)], and go left to
right 5 bits at a time.
l_divmod():
- The signature changed so that callers who don't want the quotient,
or don't want the remainder, can pass NULL in the slot they don't
want. This saves them from having to declare a vrbl for unwanted
stuff, and remembering to decref it.
long_mod(), long_div(), long_classic_div():
- Adjust to new l_divmod() signature, and simplified as a result.
2004-08-29 23:44:38 -03:00
|
|
|
Py_XDECREF(b);
|
|
|
|
Py_XDECREF(c);
|
|
|
|
Py_XDECREF(temp);
|
|
|
|
if (b->ob_size > FIVEARY_CUTOFF) {
|
|
|
|
for (i = 0; i < 32; ++i)
|
|
|
|
Py_XDECREF(table[i]);
|
|
|
|
}
|
1997-05-02 00:12:38 -03:00
|
|
|
return (PyObject *)z;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
long_invert(PyLongObject *v)
|
1991-11-19 16:26:46 -04:00
|
|
|
{
|
1992-01-14 14:36:43 -04:00
|
|
|
/* Implement ~x as -(x+1) */
|
1997-05-02 00:12:38 -03:00
|
|
|
PyLongObject *x;
|
|
|
|
PyLongObject *w;
|
|
|
|
w = (PyLongObject *)PyLong_FromLong(1L);
|
1992-01-14 14:36:43 -04:00
|
|
|
if (w == NULL)
|
|
|
|
return NULL;
|
1997-05-02 00:12:38 -03:00
|
|
|
x = (PyLongObject *) long_add(v, w);
|
|
|
|
Py_DECREF(w);
|
1992-01-14 14:36:43 -04:00
|
|
|
if (x == NULL)
|
|
|
|
return NULL;
|
2001-09-11 20:24:22 -03:00
|
|
|
x->ob_size = -(x->ob_size);
|
1997-05-02 00:12:38 -03:00
|
|
|
return (PyObject *)x;
|
1991-11-19 16:26:46 -04:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
long_pos(PyLongObject *v)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
2001-09-11 19:31:33 -03:00
|
|
|
if (PyLong_CheckExact(v)) {
|
|
|
|
Py_INCREF(v);
|
|
|
|
return (PyObject *)v;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return _PyLong_Copy(v);
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
long_neg(PyLongObject *v)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
1997-05-02 00:12:38 -03:00
|
|
|
PyLongObject *z;
|
2001-09-11 19:31:33 -03:00
|
|
|
if (v->ob_size == 0 && PyLong_CheckExact(v)) {
|
1992-01-14 14:36:43 -04:00
|
|
|
/* -0 == 0 */
|
1997-05-02 00:12:38 -03:00
|
|
|
Py_INCREF(v);
|
|
|
|
return (PyObject *) v;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
2001-09-11 19:31:33 -03:00
|
|
|
z = (PyLongObject *)_PyLong_Copy(v);
|
|
|
|
if (z != NULL)
|
|
|
|
z->ob_size = -(v->ob_size);
|
1997-05-02 00:12:38 -03:00
|
|
|
return (PyObject *)z;
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
long_abs(PyLongObject *v)
|
1991-05-05 17:09:44 -03:00
|
|
|
{
|
|
|
|
if (v->ob_size < 0)
|
1992-01-14 14:36:43 -04:00
|
|
|
return long_neg(v);
|
2001-09-11 19:31:33 -03:00
|
|
|
else
|
|
|
|
return long_pos(v);
|
1991-05-05 17:09:44 -03:00
|
|
|
}
|
|
|
|
|
1991-05-14 09:06:49 -03:00
|
|
|
static int
|
2000-07-07 12:53:28 -03:00
|
|
|
long_nonzero(PyLongObject *v)
|
1991-05-14 09:06:49 -03:00
|
|
|
{
|
1992-01-14 14:36:43 -04:00
|
|
|
return ABS(v->ob_size) != 0;
|
1991-11-19 16:26:46 -04:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2001-01-03 21:46:03 -04:00
|
|
|
long_rshift(PyLongObject *v, PyLongObject *w)
|
1991-11-19 16:26:46 -04:00
|
|
|
{
|
2001-01-03 21:46:03 -04:00
|
|
|
PyLongObject *a, *b;
|
|
|
|
PyLongObject *z = NULL;
|
1991-11-19 16:26:46 -04:00
|
|
|
long shiftby;
|
|
|
|
int newsize, wordshift, loshift, hishift, i, j;
|
|
|
|
digit lomask, himask;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
2001-01-03 21:46:03 -04:00
|
|
|
CONVERT_BINOP((PyObject *)v, (PyObject *)w, &a, &b);
|
|
|
|
|
1992-01-14 14:36:43 -04:00
|
|
|
if (a->ob_size < 0) {
|
|
|
|
/* Right shifting negative numbers is harder */
|
2001-01-03 21:46:03 -04:00
|
|
|
PyLongObject *a1, *a2;
|
1997-05-02 00:12:38 -03:00
|
|
|
a1 = (PyLongObject *) long_invert(a);
|
2001-01-03 21:46:03 -04:00
|
|
|
if (a1 == NULL)
|
|
|
|
goto rshift_error;
|
1997-05-02 00:12:38 -03:00
|
|
|
a2 = (PyLongObject *) long_rshift(a1, b);
|
|
|
|
Py_DECREF(a1);
|
2001-01-03 21:46:03 -04:00
|
|
|
if (a2 == NULL)
|
|
|
|
goto rshift_error;
|
|
|
|
z = (PyLongObject *) long_invert(a2);
|
1997-05-02 00:12:38 -03:00
|
|
|
Py_DECREF(a2);
|
1991-11-19 16:26:46 -04:00
|
|
|
}
|
2001-01-03 21:46:03 -04:00
|
|
|
else {
|
2002-08-11 23:31:19 -03:00
|
|
|
|
2001-01-03 21:46:03 -04:00
|
|
|
shiftby = PyLong_AsLong((PyObject *)b);
|
|
|
|
if (shiftby == -1L && PyErr_Occurred())
|
|
|
|
goto rshift_error;
|
|
|
|
if (shiftby < 0) {
|
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"negative shift count");
|
|
|
|
goto rshift_error;
|
|
|
|
}
|
|
|
|
wordshift = shiftby / SHIFT;
|
|
|
|
newsize = ABS(a->ob_size) - wordshift;
|
|
|
|
if (newsize <= 0) {
|
|
|
|
z = _PyLong_New(0);
|
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
|
|
|
return (PyObject *)z;
|
|
|
|
}
|
|
|
|
loshift = shiftby % SHIFT;
|
|
|
|
hishift = SHIFT - loshift;
|
|
|
|
lomask = ((digit)1 << hishift) - 1;
|
|
|
|
himask = MASK ^ lomask;
|
|
|
|
z = _PyLong_New(newsize);
|
|
|
|
if (z == NULL)
|
|
|
|
goto rshift_error;
|
|
|
|
if (a->ob_size < 0)
|
|
|
|
z->ob_size = -(z->ob_size);
|
|
|
|
for (i = 0, j = wordshift; i < newsize; i++, j++) {
|
|
|
|
z->ob_digit[i] = (a->ob_digit[j] >> loshift) & lomask;
|
|
|
|
if (i+1 < newsize)
|
|
|
|
z->ob_digit[i] |=
|
|
|
|
(a->ob_digit[j+1] << hishift) & himask;
|
|
|
|
}
|
|
|
|
z = long_normalize(z);
|
1991-11-19 16:26:46 -04:00
|
|
|
}
|
2001-01-03 21:46:03 -04:00
|
|
|
rshift_error:
|
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
|
|
|
return (PyObject *) z;
|
|
|
|
|
1991-11-19 16:26:46 -04:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2001-01-03 21:46:03 -04:00
|
|
|
long_lshift(PyObject *v, PyObject *w)
|
1991-11-19 16:26:46 -04:00
|
|
|
{
|
1997-03-15 20:37:59 -04:00
|
|
|
/* This version due to Tim Peters */
|
2001-01-03 21:46:03 -04:00
|
|
|
PyLongObject *a, *b;
|
|
|
|
PyLongObject *z = NULL;
|
1991-11-19 16:26:46 -04:00
|
|
|
long shiftby;
|
1997-03-15 20:37:59 -04:00
|
|
|
int oldsize, newsize, wordshift, remshift, i, j;
|
|
|
|
twodigits accum;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
2001-01-03 21:46:03 -04:00
|
|
|
CONVERT_BINOP(v, w, &a, &b);
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
shiftby = PyLong_AsLong((PyObject *)b);
|
|
|
|
if (shiftby == -1L && PyErr_Occurred())
|
2001-01-03 21:46:03 -04:00
|
|
|
goto lshift_error;
|
1991-11-19 16:26:46 -04:00
|
|
|
if (shiftby < 0) {
|
1997-05-02 00:12:38 -03:00
|
|
|
PyErr_SetString(PyExc_ValueError, "negative shift count");
|
2001-01-03 21:46:03 -04:00
|
|
|
goto lshift_error;
|
1991-11-19 16:26:46 -04:00
|
|
|
}
|
1997-03-15 20:37:59 -04:00
|
|
|
if ((long)(int)shiftby != shiftby) {
|
1997-05-02 00:12:38 -03:00
|
|
|
PyErr_SetString(PyExc_ValueError,
|
|
|
|
"outrageous left shift count");
|
2001-01-03 21:46:03 -04:00
|
|
|
goto lshift_error;
|
1991-11-19 16:26:46 -04:00
|
|
|
}
|
1997-03-15 20:37:59 -04:00
|
|
|
/* wordshift, remshift = divmod(shiftby, SHIFT) */
|
|
|
|
wordshift = (int)shiftby / SHIFT;
|
|
|
|
remshift = (int)shiftby - wordshift * SHIFT;
|
|
|
|
|
|
|
|
oldsize = ABS(a->ob_size);
|
|
|
|
newsize = oldsize + wordshift;
|
|
|
|
if (remshift)
|
|
|
|
++newsize;
|
1997-05-02 00:12:38 -03:00
|
|
|
z = _PyLong_New(newsize);
|
1991-11-19 16:26:46 -04:00
|
|
|
if (z == NULL)
|
2001-01-03 21:46:03 -04:00
|
|
|
goto lshift_error;
|
1991-11-19 16:26:46 -04:00
|
|
|
if (a->ob_size < 0)
|
1992-01-14 14:36:43 -04:00
|
|
|
z->ob_size = -(z->ob_size);
|
1991-11-19 16:26:46 -04:00
|
|
|
for (i = 0; i < wordshift; i++)
|
|
|
|
z->ob_digit[i] = 0;
|
2002-08-11 23:31:19 -03:00
|
|
|
accum = 0;
|
1997-03-15 20:37:59 -04:00
|
|
|
for (i = wordshift, j = 0; j < oldsize; i++, j++) {
|
2002-08-20 16:00:22 -03:00
|
|
|
accum |= (twodigits)a->ob_digit[j] << remshift;
|
1997-03-15 20:37:59 -04:00
|
|
|
z->ob_digit[i] = (digit)(accum & MASK);
|
|
|
|
accum >>= SHIFT;
|
|
|
|
}
|
|
|
|
if (remshift)
|
|
|
|
z->ob_digit[newsize-1] = (digit)accum;
|
2002-08-11 23:31:19 -03:00
|
|
|
else
|
1997-03-15 20:37:59 -04:00
|
|
|
assert(!accum);
|
2001-01-03 21:46:03 -04:00
|
|
|
z = long_normalize(z);
|
|
|
|
lshift_error:
|
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
|
|
|
return (PyObject *) z;
|
1991-11-19 16:26:46 -04:00
|
|
|
}
|
|
|
|
|
1992-01-14 14:36:43 -04:00
|
|
|
|
|
|
|
/* Bitwise and/xor/or operations */
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
long_bitwise(PyLongObject *a,
|
|
|
|
int op, /* '&', '|', '^' */
|
|
|
|
PyLongObject *b)
|
1991-11-19 16:26:46 -04:00
|
|
|
{
|
1992-01-14 14:36:43 -04:00
|
|
|
digit maska, maskb; /* 0 or MASK */
|
|
|
|
int negz;
|
|
|
|
int size_a, size_b, size_z;
|
1997-05-02 00:12:38 -03:00
|
|
|
PyLongObject *z;
|
1991-11-19 16:26:46 -04:00
|
|
|
int i;
|
1992-03-27 13:27:05 -04:00
|
|
|
digit diga, digb;
|
1997-05-02 00:12:38 -03:00
|
|
|
PyObject *v;
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1992-01-14 14:36:43 -04:00
|
|
|
if (a->ob_size < 0) {
|
1997-05-02 00:12:38 -03:00
|
|
|
a = (PyLongObject *) long_invert(a);
|
1992-01-14 14:36:43 -04:00
|
|
|
maska = MASK;
|
1991-11-19 16:26:46 -04:00
|
|
|
}
|
1992-01-14 14:36:43 -04:00
|
|
|
else {
|
1997-05-02 00:12:38 -03:00
|
|
|
Py_INCREF(a);
|
1992-01-14 14:36:43 -04:00
|
|
|
maska = 0;
|
1991-11-19 16:26:46 -04:00
|
|
|
}
|
1992-01-14 14:36:43 -04:00
|
|
|
if (b->ob_size < 0) {
|
1997-05-02 00:12:38 -03:00
|
|
|
b = (PyLongObject *) long_invert(b);
|
1992-01-14 14:36:43 -04:00
|
|
|
maskb = MASK;
|
1991-12-31 09:14:13 -04:00
|
|
|
}
|
1992-01-14 14:36:43 -04:00
|
|
|
else {
|
1997-05-02 00:12:38 -03:00
|
|
|
Py_INCREF(b);
|
1992-01-14 14:36:43 -04:00
|
|
|
maskb = 0;
|
1991-11-19 16:26:46 -04:00
|
|
|
}
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1992-01-14 14:36:43 -04:00
|
|
|
negz = 0;
|
|
|
|
switch (op) {
|
|
|
|
case '^':
|
|
|
|
if (maska != maskb) {
|
|
|
|
maska ^= MASK;
|
|
|
|
negz = -1;
|
|
|
|
}
|
|
|
|
break;
|
1994-08-29 09:47:19 -03:00
|
|
|
case '&':
|
1992-01-14 14:36:43 -04:00
|
|
|
if (maska && maskb) {
|
|
|
|
op = '|';
|
|
|
|
maska ^= MASK;
|
|
|
|
maskb ^= MASK;
|
|
|
|
negz = -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case '|':
|
|
|
|
if (maska || maskb) {
|
|
|
|
op = '&';
|
|
|
|
maska ^= MASK;
|
|
|
|
maskb ^= MASK;
|
|
|
|
negz = -1;
|
|
|
|
}
|
|
|
|
break;
|
1991-12-31 09:14:13 -04:00
|
|
|
}
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1998-08-11 12:04:47 -03:00
|
|
|
/* JRH: The original logic here was to allocate the result value (z)
|
|
|
|
as the longer of the two operands. However, there are some cases
|
|
|
|
where the result is guaranteed to be shorter than that: AND of two
|
|
|
|
positives, OR of two negatives: use the shorter number. AND with
|
|
|
|
mixed signs: use the positive number. OR with mixed signs: use the
|
|
|
|
negative number. After the transformations above, op will be '&'
|
|
|
|
iff one of these cases applies, and mask will be non-0 for operands
|
|
|
|
whose length should be ignored.
|
|
|
|
*/
|
|
|
|
|
|
|
|
size_a = a->ob_size;
|
|
|
|
size_b = b->ob_size;
|
|
|
|
size_z = op == '&'
|
|
|
|
? (maska
|
|
|
|
? size_b
|
|
|
|
: (maskb ? size_a : MIN(size_a, size_b)))
|
|
|
|
: MAX(size_a, size_b);
|
|
|
|
z = _PyLong_New(size_z);
|
|
|
|
if (a == NULL || b == NULL || z == NULL) {
|
|
|
|
Py_XDECREF(a);
|
|
|
|
Py_XDECREF(b);
|
|
|
|
Py_XDECREF(z);
|
|
|
|
return NULL;
|
|
|
|
}
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1992-01-14 14:36:43 -04:00
|
|
|
for (i = 0; i < size_z; ++i) {
|
|
|
|
diga = (i < size_a ? a->ob_digit[i] : 0) ^ maska;
|
|
|
|
digb = (i < size_b ? b->ob_digit[i] : 0) ^ maskb;
|
|
|
|
switch (op) {
|
|
|
|
case '&': z->ob_digit[i] = diga & digb; break;
|
|
|
|
case '|': z->ob_digit[i] = diga | digb; break;
|
|
|
|
case '^': z->ob_digit[i] = diga ^ digb; break;
|
|
|
|
}
|
1991-11-19 16:26:46 -04:00
|
|
|
}
|
2002-08-11 23:31:19 -03:00
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
1992-01-14 14:36:43 -04:00
|
|
|
z = long_normalize(z);
|
|
|
|
if (negz == 0)
|
1997-05-02 00:12:38 -03:00
|
|
|
return (PyObject *) z;
|
1992-01-14 14:36:43 -04:00
|
|
|
v = long_invert(z);
|
1997-05-02 00:12:38 -03:00
|
|
|
Py_DECREF(z);
|
1992-01-14 14:36:43 -04:00
|
|
|
return v;
|
1991-11-19 16:26:46 -04:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2001-01-03 21:46:03 -04:00
|
|
|
long_and(PyObject *v, PyObject *w)
|
1991-11-19 16:26:46 -04:00
|
|
|
{
|
2001-01-03 21:46:03 -04:00
|
|
|
PyLongObject *a, *b;
|
|
|
|
PyObject *c;
|
|
|
|
CONVERT_BINOP(v, w, &a, &b);
|
|
|
|
c = long_bitwise(a, '&', b);
|
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
|
|
|
return c;
|
1991-11-19 16:26:46 -04:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2001-01-03 21:46:03 -04:00
|
|
|
long_xor(PyObject *v, PyObject *w)
|
1991-11-19 16:26:46 -04:00
|
|
|
{
|
2001-01-03 21:46:03 -04:00
|
|
|
PyLongObject *a, *b;
|
|
|
|
PyObject *c;
|
|
|
|
CONVERT_BINOP(v, w, &a, &b);
|
|
|
|
c = long_bitwise(a, '^', b);
|
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
|
|
|
return c;
|
1991-11-19 16:26:46 -04:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2001-01-03 21:46:03 -04:00
|
|
|
long_or(PyObject *v, PyObject *w)
|
1991-11-19 16:26:46 -04:00
|
|
|
{
|
2001-01-03 21:46:03 -04:00
|
|
|
PyLongObject *a, *b;
|
|
|
|
PyObject *c;
|
|
|
|
CONVERT_BINOP(v, w, &a, &b);
|
|
|
|
c = long_bitwise(a, '|', b);
|
|
|
|
Py_DECREF(a);
|
|
|
|
Py_DECREF(b);
|
|
|
|
return c;
|
1991-05-14 09:06:49 -03:00
|
|
|
}
|
|
|
|
|
1993-06-17 09:35:49 -03:00
|
|
|
static int
|
2000-07-07 12:53:28 -03:00
|
|
|
long_coerce(PyObject **pv, PyObject **pw)
|
1992-08-14 09:06:52 -03:00
|
|
|
{
|
1997-05-02 00:12:38 -03:00
|
|
|
if (PyInt_Check(*pw)) {
|
2001-01-03 21:46:03 -04:00
|
|
|
*pw = PyLong_FromLong(PyInt_AS_LONG(*pw));
|
1997-05-02 00:12:38 -03:00
|
|
|
Py_INCREF(*pv);
|
1992-08-14 09:06:52 -03:00
|
|
|
return 0;
|
|
|
|
}
|
2001-09-18 22:25:16 -03:00
|
|
|
else if (PyLong_Check(*pw)) {
|
|
|
|
Py_INCREF(*pv);
|
|
|
|
Py_INCREF(*pw);
|
|
|
|
return 0;
|
|
|
|
}
|
1992-08-14 09:06:52 -03:00
|
|
|
return 1; /* Can't do it */
|
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2002-11-19 16:49:15 -04:00
|
|
|
long_long(PyObject *v)
|
1992-09-12 08:09:23 -03:00
|
|
|
{
|
2005-04-26 00:45:26 -03:00
|
|
|
if (PyLong_CheckExact(v))
|
|
|
|
Py_INCREF(v);
|
|
|
|
else
|
|
|
|
v = _PyLong_Copy((PyLongObject *)v);
|
2002-11-19 16:49:15 -04:00
|
|
|
return v;
|
1992-09-12 08:09:23 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2002-11-19 16:49:15 -04:00
|
|
|
long_int(PyObject *v)
|
1992-09-12 08:09:23 -03:00
|
|
|
{
|
2002-11-19 16:49:15 -04:00
|
|
|
long x;
|
|
|
|
x = PyLong_AsLong(v);
|
|
|
|
if (PyErr_Occurred()) {
|
|
|
|
if (PyErr_ExceptionMatches(PyExc_OverflowError)) {
|
|
|
|
PyErr_Clear();
|
|
|
|
if (PyLong_CheckExact(v)) {
|
|
|
|
Py_INCREF(v);
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return _PyLong_Copy((PyLongObject *)v);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return PyInt_FromLong(x);
|
1992-09-12 08:09:23 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
long_float(PyObject *v)
|
1992-09-12 08:09:23 -03:00
|
|
|
{
|
1997-02-14 18:54:21 -04:00
|
|
|
double result;
|
1997-05-02 00:12:38 -03:00
|
|
|
result = PyLong_AsDouble(v);
|
2001-09-04 02:14:19 -03:00
|
|
|
if (result == -1.0 && PyErr_Occurred())
|
|
|
|
return NULL;
|
1997-05-02 00:12:38 -03:00
|
|
|
return PyFloat_FromDouble(result);
|
1992-09-12 08:09:23 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
long_oct(PyObject *v)
|
1992-09-12 08:09:23 -03:00
|
|
|
{
|
1999-12-23 11:41:28 -04:00
|
|
|
return long_format(v, 8, 1);
|
1992-09-12 08:09:23 -03:00
|
|
|
}
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyObject *
|
2000-07-07 12:53:28 -03:00
|
|
|
long_hex(PyObject *v)
|
1992-09-12 08:09:23 -03:00
|
|
|
{
|
1999-12-23 11:41:28 -04:00
|
|
|
return long_format(v, 16, 1);
|
1992-09-12 08:09:23 -03:00
|
|
|
}
|
2002-07-17 13:30:39 -03:00
|
|
|
|
|
|
|
static PyObject *
|
2001-08-29 12:47:46 -03:00
|
|
|
long_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
|
1992-09-12 08:09:23 -03:00
|
|
|
|
2001-08-02 01:15:00 -03:00
|
|
|
static PyObject *
|
|
|
|
long_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|
|
|
{
|
|
|
|
PyObject *x = NULL;
|
|
|
|
int base = -909; /* unlikely! */
|
|
|
|
static char *kwlist[] = {"x", "base", 0};
|
|
|
|
|
2001-08-29 12:47:46 -03:00
|
|
|
if (type != &PyLong_Type)
|
|
|
|
return long_subtype_new(type, args, kwds); /* Wimp out */
|
2001-08-02 01:15:00 -03:00
|
|
|
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi:long", kwlist,
|
|
|
|
&x, &base))
|
|
|
|
return NULL;
|
|
|
|
if (x == NULL)
|
|
|
|
return PyLong_FromLong(0L);
|
|
|
|
if (base == -909)
|
|
|
|
return PyNumber_Long(x);
|
|
|
|
else if (PyString_Check(x))
|
|
|
|
return PyLong_FromString(PyString_AS_STRING(x), NULL, base);
|
2001-08-17 15:39:25 -03:00
|
|
|
#ifdef Py_USING_UNICODE
|
2001-08-02 01:15:00 -03:00
|
|
|
else if (PyUnicode_Check(x))
|
|
|
|
return PyLong_FromUnicode(PyUnicode_AS_UNICODE(x),
|
|
|
|
PyUnicode_GET_SIZE(x),
|
|
|
|
base);
|
2001-08-17 15:39:25 -03:00
|
|
|
#endif
|
2001-08-02 01:15:00 -03:00
|
|
|
else {
|
|
|
|
PyErr_SetString(PyExc_TypeError,
|
|
|
|
"long() can't convert non-string with explicit base");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-08-29 12:47:46 -03:00
|
|
|
/* Wimpy, slow approach to tp_new calls for subtypes of long:
|
|
|
|
first create a regular long from whatever arguments we got,
|
|
|
|
then allocate a subtype instance and initialize it from
|
|
|
|
the regular long. The regular long is then thrown away.
|
|
|
|
*/
|
|
|
|
static PyObject *
|
|
|
|
long_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
|
|
|
{
|
|
|
|
PyLongObject *tmp, *new;
|
|
|
|
int i, n;
|
|
|
|
|
|
|
|
assert(PyType_IsSubtype(type, &PyLong_Type));
|
|
|
|
tmp = (PyLongObject *)long_new(&PyLong_Type, args, kwds);
|
|
|
|
if (tmp == NULL)
|
|
|
|
return NULL;
|
2001-09-10 17:52:51 -03:00
|
|
|
assert(PyLong_CheckExact(tmp));
|
2001-08-29 12:47:46 -03:00
|
|
|
n = tmp->ob_size;
|
|
|
|
if (n < 0)
|
|
|
|
n = -n;
|
|
|
|
new = (PyLongObject *)type->tp_alloc(type, n);
|
2003-06-28 17:04:25 -03:00
|
|
|
if (new == NULL) {
|
|
|
|
Py_DECREF(tmp);
|
2001-08-29 12:47:46 -03:00
|
|
|
return NULL;
|
2003-06-28 17:04:25 -03:00
|
|
|
}
|
2001-08-29 12:47:46 -03:00
|
|
|
assert(PyLong_Check(new));
|
2001-08-30 12:54:44 -03:00
|
|
|
new->ob_size = tmp->ob_size;
|
2001-08-29 12:47:46 -03:00
|
|
|
for (i = 0; i < n; i++)
|
|
|
|
new->ob_digit[i] = tmp->ob_digit[i];
|
|
|
|
Py_DECREF(tmp);
|
|
|
|
return (PyObject *)new;
|
|
|
|
}
|
|
|
|
|
2003-01-29 13:58:45 -04:00
|
|
|
static PyObject *
|
|
|
|
long_getnewargs(PyLongObject *v)
|
|
|
|
{
|
|
|
|
return Py_BuildValue("(N)", _PyLong_Copy(v));
|
|
|
|
}
|
|
|
|
|
|
|
|
static PyMethodDef long_methods[] = {
|
|
|
|
{"__getnewargs__", (PyCFunction)long_getnewargs, METH_NOARGS},
|
|
|
|
{NULL, NULL} /* sentinel */
|
|
|
|
};
|
|
|
|
|
2002-06-13 17:33:02 -03:00
|
|
|
PyDoc_STRVAR(long_doc,
|
2001-08-02 01:15:00 -03:00
|
|
|
"long(x[, base]) -> integer\n\
|
|
|
|
\n\
|
|
|
|
Convert a string or number to a long integer, if possible. A floating\n\
|
|
|
|
point argument will be truncated towards zero (this does not include a\n\
|
|
|
|
string representation of a floating point number!) When converting a\n\
|
|
|
|
string, use the optional base. It is an error to supply a base when\n\
|
2002-06-13 17:33:02 -03:00
|
|
|
converting a non-string.");
|
2001-08-02 01:15:00 -03:00
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
static PyNumberMethods long_as_number = {
|
2000-07-07 12:53:28 -03:00
|
|
|
(binaryfunc) long_add, /*nb_add*/
|
|
|
|
(binaryfunc) long_sub, /*nb_subtract*/
|
|
|
|
(binaryfunc) long_mul, /*nb_multiply*/
|
Add warning mode for classic division, almost exactly as specified in
PEP 238. Changes:
- add a new flag variable Py_DivisionWarningFlag, declared in
pydebug.h, defined in object.c, set in main.c, and used in
{int,long,float,complex}object.c. When this flag is set, the
classic division operator issues a DeprecationWarning message.
- add a new API PyRun_SimpleStringFlags() to match
PyRun_SimpleString(). The main() function calls this so that
commands run with -c can also benefit from -Dnew.
- While I was at it, I changed the usage message in main() somewhat:
alphabetized the options, split it in *four* parts to fit in under
512 bytes (not that I still believe this is necessary -- doc strings
elsewhere are much longer), and perhaps most visibly, don't display
the full list of options on each command line error. Instead, the
full list is only displayed when -h is used, and otherwise a brief
reminder of -h is displayed. When -h is used, write to stdout so
that you can do `python -h | more'.
Notes:
- I don't want to use the -W option to control whether the classic
division warning is issued or not, because the machinery to decide
whether to display the warning or not is very expensive (it involves
calling into the warnings.py module). You can use -Werror to turn
the warnings into exceptions though.
- The -Dnew option doesn't select future division for all of the
program -- only for the __main__ module. I don't know if I'll ever
change this -- it would require changes to the .pyc file magic
number to do it right, and a more global notion of compiler flags.
- You can usefully combine -Dwarn and -Dnew: this gives the __main__
module new division, and warns about classic division everywhere
else.
2001-08-31 14:40:15 -03:00
|
|
|
(binaryfunc) long_classic_div, /*nb_divide*/
|
2000-07-07 12:53:28 -03:00
|
|
|
(binaryfunc) long_mod, /*nb_remainder*/
|
|
|
|
(binaryfunc) long_divmod, /*nb_divmod*/
|
|
|
|
(ternaryfunc) long_pow, /*nb_power*/
|
|
|
|
(unaryfunc) long_neg, /*nb_negative*/
|
|
|
|
(unaryfunc) long_pos, /*tp_positive*/
|
|
|
|
(unaryfunc) long_abs, /*tp_absolute*/
|
|
|
|
(inquiry) long_nonzero, /*tp_nonzero*/
|
|
|
|
(unaryfunc) long_invert, /*nb_invert*/
|
|
|
|
(binaryfunc) long_lshift, /*nb_lshift*/
|
|
|
|
(binaryfunc) long_rshift, /*nb_rshift*/
|
|
|
|
(binaryfunc) long_and, /*nb_and*/
|
|
|
|
(binaryfunc) long_xor, /*nb_xor*/
|
|
|
|
(binaryfunc) long_or, /*nb_or*/
|
2000-07-07 21:32:04 -03:00
|
|
|
(coercion) long_coerce, /*nb_coerce*/
|
2000-07-07 12:53:28 -03:00
|
|
|
(unaryfunc) long_int, /*nb_int*/
|
|
|
|
(unaryfunc) long_long, /*nb_long*/
|
|
|
|
(unaryfunc) long_float, /*nb_float*/
|
|
|
|
(unaryfunc) long_oct, /*nb_oct*/
|
|
|
|
(unaryfunc) long_hex, /*nb_hex*/
|
2001-08-08 02:00:18 -03:00
|
|
|
0, /* nb_inplace_add */
|
|
|
|
0, /* nb_inplace_subtract */
|
|
|
|
0, /* nb_inplace_multiply */
|
|
|
|
0, /* nb_inplace_divide */
|
|
|
|
0, /* nb_inplace_remainder */
|
|
|
|
0, /* nb_inplace_power */
|
|
|
|
0, /* nb_inplace_lshift */
|
|
|
|
0, /* nb_inplace_rshift */
|
|
|
|
0, /* nb_inplace_and */
|
|
|
|
0, /* nb_inplace_xor */
|
|
|
|
0, /* nb_inplace_or */
|
|
|
|
(binaryfunc)long_div, /* nb_floor_divide */
|
|
|
|
long_true_divide, /* nb_true_divide */
|
|
|
|
0, /* nb_inplace_floor_divide */
|
|
|
|
0, /* nb_inplace_true_divide */
|
1991-05-05 17:09:44 -03:00
|
|
|
};
|
|
|
|
|
1997-05-02 00:12:38 -03:00
|
|
|
PyTypeObject PyLong_Type = {
|
|
|
|
PyObject_HEAD_INIT(&PyType_Type)
|
2001-08-02 01:15:00 -03:00
|
|
|
0, /* ob_size */
|
|
|
|
"long", /* tp_name */
|
|
|
|
sizeof(PyLongObject) - sizeof(digit), /* tp_basicsize */
|
|
|
|
sizeof(digit), /* tp_itemsize */
|
|
|
|
(destructor)long_dealloc, /* tp_dealloc */
|
|
|
|
0, /* tp_print */
|
|
|
|
0, /* tp_getattr */
|
|
|
|
0, /* tp_setattr */
|
|
|
|
(cmpfunc)long_compare, /* tp_compare */
|
|
|
|
(reprfunc)long_repr, /* tp_repr */
|
|
|
|
&long_as_number, /* tp_as_number */
|
|
|
|
0, /* tp_as_sequence */
|
|
|
|
0, /* tp_as_mapping */
|
|
|
|
(hashfunc)long_hash, /* tp_hash */
|
|
|
|
0, /* tp_call */
|
|
|
|
(reprfunc)long_str, /* tp_str */
|
|
|
|
PyObject_GenericGetAttr, /* tp_getattro */
|
|
|
|
0, /* tp_setattro */
|
|
|
|
0, /* tp_as_buffer */
|
2001-08-29 12:47:46 -03:00
|
|
|
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES |
|
|
|
|
Py_TPFLAGS_BASETYPE, /* tp_flags */
|
2001-08-02 01:15:00 -03:00
|
|
|
long_doc, /* tp_doc */
|
|
|
|
0, /* tp_traverse */
|
|
|
|
0, /* tp_clear */
|
|
|
|
0, /* tp_richcompare */
|
|
|
|
0, /* tp_weaklistoffset */
|
|
|
|
0, /* tp_iter */
|
|
|
|
0, /* tp_iternext */
|
2003-01-29 13:58:45 -04:00
|
|
|
long_methods, /* tp_methods */
|
2001-08-02 01:15:00 -03:00
|
|
|
0, /* tp_members */
|
|
|
|
0, /* tp_getset */
|
|
|
|
0, /* tp_base */
|
|
|
|
0, /* tp_dict */
|
|
|
|
0, /* tp_descr_get */
|
|
|
|
0, /* tp_descr_set */
|
|
|
|
0, /* tp_dictoffset */
|
|
|
|
0, /* tp_init */
|
|
|
|
0, /* tp_alloc */
|
|
|
|
long_new, /* tp_new */
|
2002-04-11 23:44:10 -03:00
|
|
|
PyObject_Del, /* tp_free */
|
1991-05-05 17:09:44 -03:00
|
|
|
};
|