org.python.core.PyInteger Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jython-slim Show documentation
Show all versions of jython-slim Show documentation
Jython is an implementation of the high-level, dynamic, object-oriented
language Python written in 100% Pure Java, and seamlessly integrated with
the Java platform. It thus allows you to run Python on any Java platform.
// Copyright (c) Corporation for National Research Initiatives
// Copyright (c) Jython Developers
package org.python.core;
import java.io.Serializable;
import java.math.BigInteger;
import org.python.core.stringlib.FloatFormatter;
import org.python.core.stringlib.IntegerFormatter;
import org.python.core.stringlib.InternalFormat;
import org.python.core.stringlib.InternalFormat.Formatter;
import org.python.core.stringlib.InternalFormat.Spec;
import org.python.expose.ExposedGet;
import org.python.expose.ExposedMethod;
import org.python.expose.ExposedNew;
import org.python.expose.ExposedType;
import org.python.expose.MethodType;
/**
* A builtin python int.
*/
@Untraversable
@ExposedType(name = "int", doc = BuiltinDocs.int_doc)
public class PyInteger extends PyObject {
public static final PyType TYPE = PyType.fromClass(PyInteger.class);
/** The minimum value of an int represented by a BigInteger */
public static final BigInteger MIN_INT = BigInteger.valueOf(Integer.MIN_VALUE);
/** The maximum value of an int represented by a BigInteger */
public static final BigInteger MAX_INT = BigInteger.valueOf(Integer.MAX_VALUE);
/** @deprecated Use MIN_INT instead. */
@Deprecated
public static final BigInteger minInt = MIN_INT;
/** @deprecated Use MAX_INT instead. */
@Deprecated
public static final BigInteger maxInt = MAX_INT;
private static final String LOOKUP = "0123456789abcdef";
private final int value;
public PyInteger(PyType subType, int v) {
super(subType);
value = v;
}
public PyInteger(int v) {
this(TYPE, v);
}
@ExposedNew
public static PyObject int_new(PyNewWrapper new_, boolean init, PyType subtype,
PyObject[] args, String[] keywords) {
ArgParser ap = new ArgParser("int", args, keywords, new String[] {"x", "base"}, 0);
PyObject x = ap.getPyObject(0, null);
int base = ap.getInt(1, -909);
if (new_.for_type == subtype) { // A substantive PyInteger is required as the return value
if (x == null) {
return Py.Zero;
} else if (base == -909) {
if (x instanceof PyBoolean) {
return (coerce(x) == 0) ? Py.Zero : Py.One;
} else if (x instanceof PyByteArray) {
// Make use of the string to int conversion in PyString
PyString xs = new PyString(x.asString());
return asPyInteger(xs);
} else {
return asPyInteger(x);
}
} else if (!(x instanceof PyString)) {
throw Py.TypeError("int: can't convert non-string with explicit base");
}
try {
return Py.newInteger(((PyString)x).atoi(base));
} catch (PyException pye) {
if (pye.match(Py.OverflowError)) {
return ((PyString)x).atol(base);
}
throw pye;
}
} else { // A PyIntegerDerived(subtype, ... ) is required as the return value
if (x == null) {
return new PyIntegerDerived(subtype, 0);
} else if (base == -909) {
PyObject intOrLong = asPyInteger(x);
if (intOrLong instanceof PyInteger) {
return new PyIntegerDerived(subtype, ((PyInteger)intOrLong).getValue());
} else {
throw Py.OverflowError("long int too large to convert to int");
}
} else if (!(x instanceof PyString)) {
throw Py.TypeError("int: can't convert non-string with explicit base");
}
return new PyIntegerDerived(subtype, ((PyString)x).atoi(base));
}
} // xxx
/**
* Convert all sorts of object types to either PyInteger or PyLong,
* using their {@link PyObject#__int__()} method, whether exposed or not, or if that raises an
* exception (as the base PyObject one does), using any __trunc__()
* the type may have exposed. If all this fails, this method raises an exception. Equivalent to
* CPython PyNumber_Int().
*
* @param x to convert to an int
* @return int or long result.
* @throws PyException {@code TypeError} if no method of conversion can be found
* @throws PyException {@code AttributeError} if neither __int__ nor __trunc__ found (?)
*/
private static PyObject asPyInteger(PyObject x) throws PyException {
// XXX: Not sure that this perfectly matches CPython semantics.
try {
// Try the object itself (raises AttributeError if not overridden from PyObject)
return x.__int__();
} catch (PyException pye) {
if (!pye.match(Py.AttributeError)) {
// x had an __int__ method, but something else went wrong: pass it on
throw pye;
} else {
// x did not have an __int__ method, but maybe __trunc__ will work
try {
PyObject integral = x.invoke("__trunc__");
return convertIntegralToInt(integral);
} catch (PyException pye2) {
if (!pye2.match(Py.AttributeError)) {
throw pye2;
}
String fmt = "int() argument must be a string or a number, not '%.200s'";
throw Py.TypeError(String.format(fmt, x));
}
}
}
}
/**
* Helper called on whatever exposed method __trunc__ returned: it may be
* int, long or something with an exposed __int__.
*
* @return convert to an int.
* @throws TypeError and AttributeError.
*/
private static PyObject convertIntegralToInt(PyObject integral) {
if (!(integral instanceof PyInteger) && !(integral instanceof PyLong)) {
PyObject i = integral.invoke("__int__");
if (!(i instanceof PyInteger) && !(i instanceof PyLong)) {
throw Py.TypeError(String.format("__trunc__ returned non-Integral (type %.200s)",
integral.getType().fastGetName()));
}
return i;
}
return integral;
}
@ExposedGet(name = "real", doc = BuiltinDocs.int_real_doc)
public PyObject getReal() {
return int___int__();
}
@ExposedGet(name = "imag", doc = BuiltinDocs.int_imag_doc)
public PyObject getImag() {
return Py.newInteger(0);
}
@ExposedGet(name = "numerator", doc = BuiltinDocs.int_numerator_doc)
public PyObject getNumerator() {
return int___int__();
}
@ExposedGet(name = "denominator", doc = BuiltinDocs.int_denominator_doc)
public PyObject getDenominator() {
return Py.newInteger(1);
}
public int getValue() {
return value;
}
@Override
public String toString() {
return int_toString();
}
// XXX: need separate __doc__ for __repr__
@ExposedMethod(names = {"__str__", "__repr__"}, doc = BuiltinDocs.int___str___doc)
final String int_toString() {
return Integer.toString(getValue());
}
@Override
public int hashCode() {
return int_hashCode();
}
@ExposedMethod(names = "__hash__", doc = BuiltinDocs.int___hash___doc)
final int int_hashCode() {
return getValue();
}
@Override
public boolean __nonzero__() {
return int___nonzero__();
}
@ExposedMethod(doc = BuiltinDocs.int___nonzero___doc)
final boolean int___nonzero__() {
return getValue() != 0;
}
@Override
public Object __tojava__(Class c) {
if (c == Integer.TYPE || c == Number.class || c == Object.class || c == Integer.class
|| c == Serializable.class) {
return Integer.valueOf(getValue());
}
if (c == Boolean.TYPE || c == Boolean.class) {
return Boolean.valueOf(getValue() != 0);
}
if (c == Byte.TYPE || c == Byte.class) {
return Byte.valueOf((byte)getValue());
}
if (c == Short.TYPE || c == Short.class) {
return Short.valueOf((short)getValue());
}
if (c == Long.TYPE || c == Long.class) {
return Long.valueOf(getValue());
}
if (c == Float.TYPE || c == Float.class) {
return Float.valueOf(getValue());
}
if (c == Double.TYPE || c == Double.class) {
return Double.valueOf(getValue());
}
return super.__tojava__(c);
}
@Override
public int __cmp__(PyObject other) {
return int___cmp__(other);
}
@ExposedMethod(type = MethodType.CMP, doc = BuiltinDocs.int___cmp___doc)
final int int___cmp__(PyObject other) {
if (!canCoerce(other)) {
return -2;
}
int v = coerce(other);
return getValue() < v ? -1 : getValue() > v ? 1 : 0;
}
@Override
public Object __coerce_ex__(PyObject other) {
return int___coerce_ex__(other);
}
@ExposedMethod(doc = BuiltinDocs.int___coerce___doc)
final PyObject int___coerce__(PyObject other) {
return adaptToCoerceTuple(int___coerce_ex__(other));
}
/**
* Coercion logic for int. Implemented as a final method to avoid invocation of virtual methods
* from the exposed coerced.
*/
final Object int___coerce_ex__(PyObject other) {
return other instanceof PyInteger ? other : Py.None;
}
private static final boolean canCoerce(PyObject other) {
return other instanceof PyInteger;
}
private static final int coerce(PyObject other) {
if (other instanceof PyInteger) {
return ((PyInteger)other).getValue();
}
throw Py.TypeError("xxx");
}
@Override
public PyObject __add__(PyObject right) {
return int___add__(right);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___add___doc)
final PyObject int___add__(PyObject right) {
if (!canCoerce(right)) {
return null;
}
int rightv = coerce(right);
int a = getValue();
int b = rightv;
int x = a + b;
if ((x ^ a) >= 0 || (x ^ b) >= 0) {
return Py.newInteger(x);
}
return new PyLong((long)a + (long)b);
}
@Override
public PyObject __radd__(PyObject left) {
return int___radd__(left);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___radd___doc)
final PyObject int___radd__(PyObject left) {
return __add__(left);
}
private static PyObject _sub(int a, int b) {
int x = a - b;
if ((x ^ a) >= 0 || (x ^ ~b) >= 0) {
return Py.newInteger(x);
}
return new PyLong((long)a - (long)b);
}
@Override
public PyObject __sub__(PyObject right) {
return int___sub__(right);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___sub___doc)
final PyObject int___sub__(PyObject right) {
if (!canCoerce(right)) {
return null;
}
return _sub(getValue(), coerce(right));
}
@Override
public PyObject __rsub__(PyObject left) {
return int___rsub__(left);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___rsub___doc)
final PyObject int___rsub__(PyObject left) {
if (!canCoerce(left)) {
return null;
}
return _sub(coerce(left), getValue());
}
@Override
public PyObject __mul__(PyObject right) {
return int___mul__(right);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___mul___doc)
final PyObject int___mul__(PyObject right) {
if (!canCoerce(right)) {
return null;
}
int rightv = coerce(right);
double x = getValue();
x *= rightv;
if (x <= Integer.MAX_VALUE && x >= Integer.MIN_VALUE) {
return Py.newInteger((int)x);
}
return __long__().__mul__(right);
}
@Override
public PyObject __rmul__(PyObject left) {
return int___rmul__(left);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___rmul___doc)
final PyObject int___rmul__(PyObject left) {
return __mul__(left);
}
// Getting signs correct for integer division
// This convention makes sense when you consider it in tandem with modulo
private static long divide(long x, long y) {
if (y == 0) {
throw Py.ZeroDivisionError("integer division or modulo by zero");
}
long xdivy = x / y;
long xmody = x - xdivy * y;
// If the signs of x and y differ, and the remainder is non-0, C89 doesn't define
// whether xdivy is now the floor or the ceiling of the infinitely precise
// quotient. We want the floor, and we have it iff the remainder's sign matches
// y's.
if (xmody != 0 && ((y < 0 && xmody > 0) || (y > 0 && xmody < 0))) {
xmody += y;
--xdivy;
// assert(xmody && ((y ^ xmody) >= 0));
}
return xdivy;
}
@Override
public PyObject __div__(PyObject right) {
return int___div__(right);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___div___doc)
final PyObject int___div__(PyObject right) {
if (!canCoerce(right)) {
return null;
}
if (Options.division_warning > 0) {
Py.warning(Py.DeprecationWarning, "classic int division");
}
return Py.newInteger(divide(getValue(), coerce(right)));
}
@Override
public PyObject __rdiv__(PyObject left) {
return int___rdiv__(left);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___rdiv___doc)
final PyObject int___rdiv__(PyObject left) {
if (!canCoerce(left)) {
return null;
}
if (Options.division_warning > 0) {
Py.warning(Py.DeprecationWarning, "classic int division");
}
return Py.newInteger(divide(coerce(left), getValue()));
}
@Override
public PyObject __floordiv__(PyObject right) {
return int___floordiv__(right);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___floordiv___doc)
final PyObject int___floordiv__(PyObject right) {
if (!canCoerce(right)) {
return null;
}
return Py.newInteger(divide(getValue(), coerce(right)));
}
@Override
public PyObject __rfloordiv__(PyObject left) {
return int___rfloordiv__(left);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___rfloordiv___doc)
final PyObject int___rfloordiv__(PyObject left) {
if (!canCoerce(left)) {
return null;
}
return Py.newInteger(divide(coerce(left), getValue()));
}
@Override
public PyObject __truediv__(PyObject right) {
return int___truediv__(right);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___truediv___doc)
final PyObject int___truediv__(PyObject right) {
if (right instanceof PyInteger) {
return __float__().__truediv__(right);
} else if (right instanceof PyLong) {
return int___long__().__truediv__(right);
} else {
return null;
}
}
@Override
public PyObject __rtruediv__(PyObject left) {
return int___rtruediv__(left);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___rtruediv___doc)
final PyObject int___rtruediv__(PyObject left) {
if (left instanceof PyInteger) {
return left.__float__().__truediv__(this);
} else if (left instanceof PyLong) {
return left.__truediv__(int___long__());
} else {
return null;
}
}
private static long modulo(long x, long y, long xdivy) {
return x - xdivy * y;
}
@Override
public PyObject __mod__(PyObject right) {
return int___mod__(right);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___mod___doc)
final PyObject int___mod__(PyObject right) {
if (!canCoerce(right)) {
return null;
}
int rightv = coerce(right);
int v = getValue();
return Py.newInteger(modulo(v, rightv, divide(v, rightv)));
}
@Override
public PyObject __rmod__(PyObject left) {
return int___rmod__(left);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___rmod___doc)
final PyObject int___rmod__(PyObject left) {
if (!canCoerce(left)) {
return null;
}
int leftv = coerce(left);
int v = getValue();
return Py.newInteger(modulo(leftv, v, divide(leftv, v)));
}
@Override
public PyObject __divmod__(PyObject right) {
return int___divmod__(right);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___divmod___doc)
final PyObject int___divmod__(PyObject right) {
if (!canCoerce(right)) {
return null;
}
int rightv = coerce(right);
int v = getValue();
long xdivy = divide(v, rightv);
return new PyTuple(Py.newInteger(xdivy), Py.newInteger(modulo(v, rightv, xdivy)));
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___rdivmod___doc)
final PyObject int___rdivmod__(PyObject left) {
if (!canCoerce(left)) {
return null;
}
int leftv = coerce(left);
int v = getValue();
long xdivy = divide(leftv, v);
return new PyTuple(Py.newInteger(xdivy), Py.newInteger(modulo(leftv, v, xdivy)));
}
@Override
public PyObject __pow__(PyObject right, PyObject modulo) {
return int___pow__(right, modulo);
}
@ExposedMethod(type = MethodType.BINARY, defaults = {"null"}, //
doc = BuiltinDocs.int___pow___doc)
final PyObject int___pow__(PyObject right, PyObject modulo) {
if (!canCoerce(right)) {
return null;
}
modulo = (modulo == Py.None) ? null : modulo;
if (modulo != null && !canCoerce(modulo)) {
return null;
}
return _pow(getValue(), coerce(right), modulo, this, right);
}
@Override
public PyObject __rpow__(PyObject left) {
if (!canCoerce(left)) {
return null;
}
return _pow(coerce(left), getValue(), null, left, this);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___rpow___doc)
final PyObject int___rpow__(PyObject left) {
return __rpow__(left);
}
private static PyObject _pow(int value, int pow, PyObject modulo,//
PyObject left, PyObject right) {
int mod = 0;
long tmp = value;
boolean neg = false;
if (tmp < 0) {
tmp = -tmp;
neg = (pow & 0x1) != 0;
}
long result = 1;
if (pow < 0) {
if (value != 0) {
return left.__float__().__pow__(right, modulo);
} else {
throw Py.ZeroDivisionError("0.0 cannot be raised to a negative power");
}
}
if (modulo != null) {
mod = coerce(modulo);
if (mod == 0) {
throw Py.ValueError("pow(x, y, z) with z==0");
}
}
// Standard O(ln(N)) exponentiation code
while (pow > 0) {
if ((pow & 0x1) != 0) {
result *= tmp;
if (mod != 0) {
result %= mod;
}
if (result > Integer.MAX_VALUE) {
return left.__long__().__pow__(right, modulo);
}
}
pow >>= 1;
if (pow == 0) {
break;
}
tmp *= tmp;
if (mod != 0) {
tmp %= mod;
}
if (tmp > Integer.MAX_VALUE) {
return left.__long__().__pow__(right, modulo);
}
}
if (neg) {
result = -result;
}
// Cleanup result of modulo
if (mod != 0) {
result = modulo(result, mod, divide(result, mod));
}
return Py.newInteger(result);
}
@Override
public PyObject __lshift__(PyObject right) {
return int___lshift__(right);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___lshift___doc)
final PyObject int___lshift__(PyObject right) {
int rightv;
if (right instanceof PyInteger) {
rightv = ((PyInteger)right).getValue();
} else if (right instanceof PyLong) {
return int___long__().__lshift__(right);
} else {
return null;
}
if (rightv >= Integer.SIZE) {
return __long__().__lshift__(right);
} else if (rightv < 0) {
throw Py.ValueError("negative shift count");
}
int result = getValue() << rightv;
if (getValue() != result >> rightv) {
return __long__().__lshift__(right);
}
return Py.newInteger(result);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___rlshift___doc)
final PyObject int___rlshift__(PyObject left) {
int leftv;
if (left instanceof PyInteger) {
leftv = ((PyInteger)left).getValue();
} else if (left instanceof PyLong) {
return left.__rlshift__(int___long__());
} else {
return null;
}
if (getValue() >= Integer.SIZE) {
return left.__long__().__lshift__(this);
} else if (getValue() < 0) {
throw Py.ValueError("negative shift count");
}
int result = leftv << getValue();
if (leftv != result >> getValue()) {
return left.__long__().__lshift__(this);
}
return Py.newInteger(result);
}
@Override
public PyObject __rshift__(PyObject right) {
return int___rshift__(right);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___rshift___doc)
final PyObject int___rshift__(PyObject right) {
int rightv;
if (right instanceof PyInteger) {
rightv = ((PyInteger)right).getValue();
} else if (right instanceof PyLong) {
return int___long__().__rshift__(right);
} else {
return null;
}
if (rightv < 0) {
throw Py.ValueError("negative shift count");
}
if (rightv >= Integer.SIZE) {
return Py.newInteger(getValue() < 0 ? -1 : 0);
}
return Py.newInteger(getValue() >> rightv);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___rrshift___doc)
final PyObject int___rrshift__(PyObject left) {
int leftv;
if (left instanceof PyInteger) {
leftv = ((PyInteger)left).getValue();
} else if (left instanceof PyLong) {
return left.__rshift__(int___long__());
} else {
return null;
}
if (getValue() < 0) {
throw Py.ValueError("negative shift count");
}
if (getValue() >= Integer.SIZE) {
return Py.newInteger(leftv < 0 ? -1 : 0);
}
return Py.newInteger(leftv >> getValue());
}
@Override
public PyObject __and__(PyObject right) {
return int___and__(right);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___and___doc)
final PyObject int___and__(PyObject right) {
int rightv;
if (right instanceof PyInteger) {
rightv = ((PyInteger)right).getValue();
} else if (right instanceof PyLong) {
return int___long__().__and__(right);
} else {
return null;
}
return Py.newInteger(getValue() & rightv);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___rand___doc)
final PyObject int___rand__(PyObject left) {
return int___and__(left);
}
@Override
public PyObject __xor__(PyObject right) {
return int___xor__(right);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___xor___doc)
final PyObject int___xor__(PyObject right) {
int rightv;
if (right instanceof PyInteger) {
rightv = ((PyInteger)right).getValue();
} else if (right instanceof PyLong) {
return int___long__().__xor__(right);
} else {
return null;
}
return Py.newInteger(getValue() ^ rightv);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___rxor___doc)
final PyObject int___rxor__(PyObject left) {
int leftv;
if (left instanceof PyInteger) {
leftv = ((PyInteger)left).getValue();
} else if (left instanceof PyLong) {
return left.__rxor__(int___long__());
} else {
return null;
}
return Py.newInteger(leftv ^ getValue());
}
@Override
public PyObject __or__(PyObject right) {
return int___or__(right);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___or___doc)
final PyObject int___or__(PyObject right) {
int rightv;
if (right instanceof PyInteger) {
rightv = ((PyInteger)right).getValue();
} else if (right instanceof PyLong) {
return int___long__().__or__(right);
} else {
return null;
}
return Py.newInteger(getValue() | rightv);
}
@ExposedMethod(type = MethodType.BINARY, doc = BuiltinDocs.int___ror___doc)
final PyObject int___ror__(PyObject left) {
return int___or__(left);
}
@Override
public PyObject __neg__() {
return int___neg__();
}
@ExposedMethod(doc = BuiltinDocs.int___neg___doc)
final PyObject int___neg__() {
long x = getValue();
long result = -x;
// check for overflow
if (x < 0 && result == x) {
return new PyLong(x).__neg__();
}
return Py.newInteger(result);
}
@Override
public PyObject __pos__() {
return int___pos__();
}
@ExposedMethod(doc = BuiltinDocs.int___pos___doc)
final PyObject int___pos__() {
return int___int__();
}
@Override
public PyObject __abs__() {
return int___abs__();
}
@ExposedMethod(doc = BuiltinDocs.int___abs___doc)
final PyObject int___abs__() {
if (getValue() < 0) {
return int___neg__();
}
return int___int__();
}
@Override
public PyObject __invert__() {
return int___invert__();
}
@ExposedMethod(doc = BuiltinDocs.int___invert___doc)
final PyObject int___invert__() {
return Py.newInteger(~getValue());
}
@Override
public PyObject __int__() {
return int___int__();
}
@ExposedMethod(doc = BuiltinDocs.int___int___doc)
final PyInteger int___int__() {
return getType() == TYPE ? this : Py.newInteger(getValue());
}
@Override
public PyObject __long__() {
return int___long__();
}
@ExposedMethod(doc = BuiltinDocs.int___long___doc)
final PyObject int___long__() {
return new PyLong(getValue());
}
@Override
public PyFloat __float__() {
return int___float__();
}
@ExposedMethod(doc = BuiltinDocs.int___float___doc)
final PyFloat int___float__() {
return new PyFloat((double)getValue());
}
@Override
public PyObject __trunc__() {
return int___trunc__();
}
@ExposedMethod(doc = BuiltinDocs.int___trunc___doc)
final PyObject int___trunc__() {
return this;
}
@Override
public PyObject conjugate() {
return int_conjugate();
}
@ExposedMethod(doc = BuiltinDocs.int_conjugate_doc)
final PyObject int_conjugate() {
return this;
}
@Override
public PyComplex __complex__() {
return new PyComplex(getValue(), 0.);
}
@Override
public PyString __oct__() {
return int___oct__();
}
@ExposedMethod(doc = BuiltinDocs.int___oct___doc)
final PyString int___oct__() {
// Use the prepared format specifier for octal.
return formatImpl(IntegerFormatter.OCT);
}
@Override
public PyString __hex__() {
return int___hex__();
}
@ExposedMethod(doc = BuiltinDocs.int___hex___doc)
final PyString int___hex__() {
// Use the prepared format specifier for hexadecimal.
return formatImpl(IntegerFormatter.HEX);
}
/**
* Common code used by the number-base conversion method __oct__ and __hex__.
*
* @param spec prepared format-specifier.
* @return converted value of this object
*/
private PyString formatImpl(Spec spec) {
// Traditional formatter (%-format) because #o means "-0123" not "-0o123".
IntegerFormatter f = new IntegerFormatter.Traditional(spec);
f.format(value);
return new PyString(f.getResult());
}
@ExposedMethod(doc = BuiltinDocs.int___getnewargs___doc)
final PyTuple int___getnewargs__() {
return new PyTuple(new PyObject[] {new PyInteger(this.getValue())});
}
@Override
public PyTuple __getnewargs__() {
return int___getnewargs__();
}
@Override
public PyObject __index__() {
return int___index__();
}
@ExposedMethod(doc = BuiltinDocs.int___index___doc)
final PyObject int___index__() {
return this;
}
@Override
public int bit_length() {
return int_bit_length();
}
@ExposedMethod(doc = BuiltinDocs.int_bit_length_doc)
final int int_bit_length() {
int v = value;
if (v < 0) {
v = -v;
}
return BigInteger.valueOf(v).bitLength();
}
@Override
public PyObject __format__(PyObject formatSpec) {
return int___format__(formatSpec);
}
@ExposedMethod(doc = BuiltinDocs.int___format___doc)
final PyObject int___format__(PyObject formatSpec) {
// Parse the specification
Spec spec = InternalFormat.fromText(formatSpec, "__format__");
InternalFormat.Formatter f;
// Try to make an integer formatter from the specification
IntegerFormatter fi = PyInteger.prepareFormatter(spec);
if (fi != null) {
// Bytes mode if formatSpec argument is not unicode.
fi.setBytes(!(formatSpec instanceof PyUnicode));
// Convert as per specification.
fi.format(value);
f = fi;
} else {
// Try to make a float formatter from the specification
FloatFormatter ff = PyFloat.prepareFormatter(spec);
if (ff != null) {
// Bytes mode if formatSpec argument is not unicode.
ff.setBytes(!(formatSpec instanceof PyUnicode));
// Convert as per specification.
ff.format(value);
f = ff;
} else {
// The type code was not recognised in either prepareFormatter
throw Formatter.unknownFormat(spec.type, "integer");
}
}
// Return a result that has the same type (str or unicode) as the formatSpec argument.
return f.pad().getPyResult();
}
/**
* Common code for PyInteger and PyLong to prepare an IntegerFormatter. This object has an
* overloaded format method {@link IntegerFormatter#format(int)} and
* {@link IntegerFormatter#format(BigInteger)} to support the two types.
*
* @param spec a parsed PEP-3101 format specification.
* @return a formatter ready to use, or null if the type is not an integer format type.
* @throws PyException {@code ValueError} if the specification is faulty.
*/
@SuppressWarnings("fallthrough")
static IntegerFormatter prepareFormatter(Spec spec) throws PyException {
// Slight differences between format types
switch (spec.type) {
case 'c':
// Character data: specific prohibitions.
if (Spec.specified(spec.sign)) {
throw IntegerFormatter.signNotAllowed("integer", spec.type);
} else if (spec.alternate) {
throw IntegerFormatter.alternateFormNotAllowed("integer", spec.type);
}
// Fall through
case 'x':
case 'X':
case 'o':
case 'b':
case 'n':
if (spec.grouping) {
throw IntegerFormatter.notAllowed("Grouping", "integer", spec.type);
}
// Fall through
case Spec.NONE:
case 'd':
// Check for disallowed parts of the specification
if (Spec.specified(spec.precision)) {
throw IntegerFormatter.precisionNotAllowed("integer");
}
// spec may be incomplete. The defaults are those commonly used for numeric formats.
spec = spec.withDefaults(Spec.NUMERIC);
// Get a formatter for the spec.
return new IntegerFormatter(spec);
default:
return null;
}
}
@Override
public boolean isIndex() {
return true;
}
@Override
public int asIndex(PyObject err) {
return getValue();
}
@Override
public boolean isMappingType() {
return false;
}
@Override
public boolean isNumberType() {
return true;
}
@Override
public boolean isSequenceType() {
return false;
}
@Override
public long asLong(int index) {
return getValue();
}
@Override
public int asInt(int index) {
return getValue();
}
@Override
public int asInt() {
return getValue();
}
@Override
public long asLong() {
return getValue();
}
}