Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.python.core.PyLong Maven / Gradle / Ivy
// Copyright (c) Corporation for National Research Initiatives
package org.python.core;
import java.math.BigInteger;
import java.io.Serializable;
/**
* A builtin python long. This is implemented as a
* java.math.BigInteger.
*/
public class PyLong extends PyObject
{
public static final BigInteger minLong =
BigInteger.valueOf(Long.MIN_VALUE);
public static final BigInteger maxLong =
BigInteger.valueOf(Long.MAX_VALUE);
public static final BigInteger maxULong =
BigInteger.valueOf(1).shiftLeft(64).subtract(BigInteger.valueOf(1));
//~ BEGIN GENERATED REGION -- DO NOT EDIT SEE gexpose.py
/* type info */
public static final String exposed_name="long";
public static void typeSetup(PyObject dict,PyType.Newstyle marker) {
class exposed___abs__ extends PyBuiltinMethodNarrow {
exposed___abs__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___abs__(self,info);
}
public PyObject __call__() {
return((PyLong)self).long___abs__();
}
}
dict.__setitem__("__abs__",new PyMethodDescr("__abs__",PyLong.class,0,0,new exposed___abs__(null,null)));
class exposed___float__ extends PyBuiltinMethodNarrow {
exposed___float__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___float__(self,info);
}
public PyObject __call__() {
return((PyLong)self).long___float__();
}
}
dict.__setitem__("__float__",new PyMethodDescr("__float__",PyLong.class,0,0,new exposed___float__(null,null)));
class exposed___hex__ extends PyBuiltinMethodNarrow {
exposed___hex__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___hex__(self,info);
}
public PyObject __call__() {
return((PyLong)self).long___hex__();
}
}
dict.__setitem__("__hex__",new PyMethodDescr("__hex__",PyLong.class,0,0,new exposed___hex__(null,null)));
class exposed___int__ extends PyBuiltinMethodNarrow {
exposed___int__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___int__(self,info);
}
public PyObject __call__() {
return((PyLong)self).long___int__();
}
}
dict.__setitem__("__int__",new PyMethodDescr("__int__",PyLong.class,0,0,new exposed___int__(null,null)));
class exposed___invert__ extends PyBuiltinMethodNarrow {
exposed___invert__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___invert__(self,info);
}
public PyObject __call__() {
return((PyLong)self).long___invert__();
}
}
dict.__setitem__("__invert__",new PyMethodDescr("__invert__",PyLong.class,0,0,new exposed___invert__(null,null)));
class exposed___long__ extends PyBuiltinMethodNarrow {
exposed___long__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___long__(self,info);
}
public PyObject __call__() {
return((PyLong)self).long___long__();
}
}
dict.__setitem__("__long__",new PyMethodDescr("__long__",PyLong.class,0,0,new exposed___long__(null,null)));
class exposed___neg__ extends PyBuiltinMethodNarrow {
exposed___neg__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___neg__(self,info);
}
public PyObject __call__() {
return((PyLong)self).long___neg__();
}
}
dict.__setitem__("__neg__",new PyMethodDescr("__neg__",PyLong.class,0,0,new exposed___neg__(null,null)));
class exposed___oct__ extends PyBuiltinMethodNarrow {
exposed___oct__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___oct__(self,info);
}
public PyObject __call__() {
return((PyLong)self).long___oct__();
}
}
dict.__setitem__("__oct__",new PyMethodDescr("__oct__",PyLong.class,0,0,new exposed___oct__(null,null)));
class exposed___pos__ extends PyBuiltinMethodNarrow {
exposed___pos__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___pos__(self,info);
}
public PyObject __call__() {
return((PyLong)self).long___pos__();
}
}
dict.__setitem__("__pos__",new PyMethodDescr("__pos__",PyLong.class,0,0,new exposed___pos__(null,null)));
class exposed___add__ extends PyBuiltinMethodNarrow {
exposed___add__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___add__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___add__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__add__",new PyMethodDescr("__add__",PyLong.class,1,1,new exposed___add__(null,null)));
class exposed___and__ extends PyBuiltinMethodNarrow {
exposed___and__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___and__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___and__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__and__",new PyMethodDescr("__and__",PyLong.class,1,1,new exposed___and__(null,null)));
class exposed___div__ extends PyBuiltinMethodNarrow {
exposed___div__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___div__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___div__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__div__",new PyMethodDescr("__div__",PyLong.class,1,1,new exposed___div__(null,null)));
class exposed___divmod__ extends PyBuiltinMethodNarrow {
exposed___divmod__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___divmod__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___divmod__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__divmod__",new PyMethodDescr("__divmod__",PyLong.class,1,1,new exposed___divmod__(null,null)));
class exposed___floordiv__ extends PyBuiltinMethodNarrow {
exposed___floordiv__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___floordiv__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___floordiv__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__floordiv__",new PyMethodDescr("__floordiv__",PyLong.class,1,1,new exposed___floordiv__(null,null)));
class exposed___lshift__ extends PyBuiltinMethodNarrow {
exposed___lshift__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___lshift__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___lshift__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__lshift__",new PyMethodDescr("__lshift__",PyLong.class,1,1,new exposed___lshift__(null,null)));
class exposed___mod__ extends PyBuiltinMethodNarrow {
exposed___mod__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___mod__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___mod__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__mod__",new PyMethodDescr("__mod__",PyLong.class,1,1,new exposed___mod__(null,null)));
class exposed___mul__ extends PyBuiltinMethodNarrow {
exposed___mul__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___mul__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___mul__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__mul__",new PyMethodDescr("__mul__",PyLong.class,1,1,new exposed___mul__(null,null)));
class exposed___or__ extends PyBuiltinMethodNarrow {
exposed___or__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___or__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___or__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__or__",new PyMethodDescr("__or__",PyLong.class,1,1,new exposed___or__(null,null)));
class exposed___radd__ extends PyBuiltinMethodNarrow {
exposed___radd__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___radd__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___radd__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__radd__",new PyMethodDescr("__radd__",PyLong.class,1,1,new exposed___radd__(null,null)));
class exposed___rdiv__ extends PyBuiltinMethodNarrow {
exposed___rdiv__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rdiv__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___rdiv__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rdiv__",new PyMethodDescr("__rdiv__",PyLong.class,1,1,new exposed___rdiv__(null,null)));
class exposed___rfloordiv__ extends PyBuiltinMethodNarrow {
exposed___rfloordiv__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rfloordiv__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___rfloordiv__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rfloordiv__",new PyMethodDescr("__rfloordiv__",PyLong.class,1,1,new exposed___rfloordiv__(null,null)));
class exposed___rmod__ extends PyBuiltinMethodNarrow {
exposed___rmod__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rmod__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___rmod__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rmod__",new PyMethodDescr("__rmod__",PyLong.class,1,1,new exposed___rmod__(null,null)));
class exposed___rmul__ extends PyBuiltinMethodNarrow {
exposed___rmul__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rmul__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___rmul__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rmul__",new PyMethodDescr("__rmul__",PyLong.class,1,1,new exposed___rmul__(null,null)));
class exposed___rshift__ extends PyBuiltinMethodNarrow {
exposed___rshift__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rshift__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___rshift__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rshift__",new PyMethodDescr("__rshift__",PyLong.class,1,1,new exposed___rshift__(null,null)));
class exposed___rsub__ extends PyBuiltinMethodNarrow {
exposed___rsub__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rsub__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___rsub__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rsub__",new PyMethodDescr("__rsub__",PyLong.class,1,1,new exposed___rsub__(null,null)));
class exposed___rtruediv__ extends PyBuiltinMethodNarrow {
exposed___rtruediv__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rtruediv__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___rtruediv__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rtruediv__",new PyMethodDescr("__rtruediv__",PyLong.class,1,1,new exposed___rtruediv__(null,null)));
class exposed___sub__ extends PyBuiltinMethodNarrow {
exposed___sub__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___sub__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___sub__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__sub__",new PyMethodDescr("__sub__",PyLong.class,1,1,new exposed___sub__(null,null)));
class exposed___truediv__ extends PyBuiltinMethodNarrow {
exposed___truediv__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___truediv__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___truediv__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__truediv__",new PyMethodDescr("__truediv__",PyLong.class,1,1,new exposed___truediv__(null,null)));
class exposed___xor__ extends PyBuiltinMethodNarrow {
exposed___xor__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___xor__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___xor__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__xor__",new PyMethodDescr("__xor__",PyLong.class,1,1,new exposed___xor__(null,null)));
class exposed___rxor__ extends PyBuiltinMethodNarrow {
exposed___rxor__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rxor__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___rxor__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rxor__",new PyMethodDescr("__rxor__",PyLong.class,1,1,new exposed___rxor__(null,null)));
class exposed___rrshift__ extends PyBuiltinMethodNarrow {
exposed___rrshift__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rrshift__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___rrshift__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rrshift__",new PyMethodDescr("__rrshift__",PyLong.class,1,1,new exposed___rrshift__(null,null)));
class exposed___ror__ extends PyBuiltinMethodNarrow {
exposed___ror__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___ror__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___ror__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__ror__",new PyMethodDescr("__ror__",PyLong.class,1,1,new exposed___ror__(null,null)));
class exposed___rand__ extends PyBuiltinMethodNarrow {
exposed___rand__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rand__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___rand__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rand__",new PyMethodDescr("__rand__",PyLong.class,1,1,new exposed___rand__(null,null)));
class exposed___rpow__ extends PyBuiltinMethodNarrow {
exposed___rpow__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rpow__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___rpow__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rpow__",new PyMethodDescr("__rpow__",PyLong.class,1,1,new exposed___rpow__(null,null)));
class exposed___rlshift__ extends PyBuiltinMethodNarrow {
exposed___rlshift__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rlshift__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___rlshift__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rlshift__",new PyMethodDescr("__rlshift__",PyLong.class,1,1,new exposed___rlshift__(null,null)));
class exposed___rdivmod__ extends PyBuiltinMethodNarrow {
exposed___rdivmod__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___rdivmod__(self,info);
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___rdivmod__(arg0);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rdivmod__",new PyMethodDescr("__rdivmod__",PyLong.class,1,1,new exposed___rdivmod__(null,null)));
class exposed___cmp__ extends PyBuiltinMethodNarrow {
exposed___cmp__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___cmp__(self,info);
}
public PyObject __call__(PyObject arg0) {
int ret=((PyLong)self).long___cmp__(arg0);
if (ret==-2) {
throw Py.TypeError("long"+".__cmp__(x,y) requires y to be '"+"long"+"', not a '"+(arg0).getType().fastGetName()+"'");
}
return Py.newInteger(ret);
}
}
dict.__setitem__("__cmp__",new PyMethodDescr("__cmp__",PyLong.class,1,1,new exposed___cmp__(null,null)));
class exposed___pow__ extends PyBuiltinMethodNarrow {
exposed___pow__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___pow__(self,info);
}
public PyObject __call__(PyObject arg0,PyObject arg1) {
PyObject ret=((PyLong)self).long___pow__(arg0,arg1);
if (ret==null)
return Py.NotImplemented;
return ret;
}
public PyObject __call__(PyObject arg0) {
PyObject ret=((PyLong)self).long___pow__(arg0,null);
if (ret==null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__pow__",new PyMethodDescr("__pow__",PyLong.class,1,2,new exposed___pow__(null,null)));
class exposed___nonzero__ extends PyBuiltinMethodNarrow {
exposed___nonzero__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___nonzero__(self,info);
}
public PyObject __call__() {
return Py.newBoolean(((PyLong)self).long___nonzero__());
}
}
dict.__setitem__("__nonzero__",new PyMethodDescr("__nonzero__",PyLong.class,0,0,new exposed___nonzero__(null,null)));
class exposed___repr__ extends PyBuiltinMethodNarrow {
exposed___repr__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___repr__(self,info);
}
public PyObject __call__() {
return new PyString(((PyLong)self).long_toString());
}
}
dict.__setitem__("__repr__",new PyMethodDescr("__repr__",PyLong.class,0,0,new exposed___repr__(null,null)));
class exposed___str__ extends PyBuiltinMethodNarrow {
exposed___str__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___str__(self,info);
}
public PyObject __call__() {
return new PyString(((PyLong)self).long_toString());
}
}
dict.__setitem__("__str__",new PyMethodDescr("__str__",PyLong.class,0,0,new exposed___str__(null,null)));
class exposed___hash__ extends PyBuiltinMethodNarrow {
exposed___hash__(PyObject self,PyBuiltinFunction.Info info) {
super(self,info);
}
public PyBuiltinFunction bind(PyObject self) {
return new exposed___hash__(self,info);
}
public PyObject __call__() {
return Py.newInteger(((PyLong)self).long_hashCode());
}
}
dict.__setitem__("__hash__",new PyMethodDescr("__hash__",PyLong.class,0,0,new exposed___hash__(null,null)));
dict.__setitem__("__new__",new PyNewWrapper(PyLong.class,"__new__",-1,-1) {
public PyObject new_impl(boolean init,PyType subtype,PyObject[]args,String[]keywords) {
return long_new(this,init,subtype,args,keywords);
}
});
}
//~ END GENERATED REGION -- DO NOT EDIT SEE gexpose.py
private BigInteger value;
public static PyObject long_new(PyNewWrapper new_, boolean init, PyType subtype,
PyObject[] args, String[] keywords) {
ArgParser ap = new ArgParser(exposed_name, args, keywords,
new String[] { "x", "base" }, 0);
PyObject x = ap.getPyObject(0, null);
int base = ap.getInt(1, -909);
if (new_.for_type == subtype) {
if (x == null) {
return Py.Zero;
}
Object o = x.__tojava__(BigInteger.class);
if(o != Py.NoConversion) {
return Py.newLong((BigInteger)o);
}
if (base == -909) {
return x.__long__();
}
if (!(x instanceof PyString)) {
throw Py.TypeError("long: can't convert non-string with explicit base");
}
return ((PyString) x).atol(base);
} else {
if (x == null) {
return new PyLongDerived(subtype, BigInteger.valueOf(0));
}
Object o = x.__tojava__(BigInteger.class);
if(o != Py.NoConversion) {
return new PyLongDerived(subtype, (BigInteger)o);
}
if (base == -909) {
return new PyLongDerived(subtype, x.__long__().getValue());
}
if (!(x instanceof PyString)) {
throw Py.TypeError("long: can't convert non-string with explicit base");
}
return new PyLongDerived(subtype, (((PyString) x).atol(base)).getValue());
}
} // xxx
private static final PyType LONGTYPE = PyType.fromClass(PyLong.class);
public PyLong(PyType subType, BigInteger v) {
super(subType);
value = v;
}
public PyLong(BigInteger v) {
this(LONGTYPE, v);
}
public PyLong(double v) {
this(new java.math.BigDecimal(v).toBigInteger());
}
public PyLong(long v) {
this(BigInteger.valueOf(v));
}
public PyLong(String s) {
this(new BigInteger(s));
}
public BigInteger getValue() {
return value;
}
public String toString() {
return long_toString();
}
final String long_toString() {
return value.toString()+"L";
}
public int hashCode() {
return long_hashCode();
}
final int long_hashCode() {
// Probably won't work well for some classes of keys...
return value.intValue();
}
public boolean __nonzero__() {
return !value.equals(BigInteger.valueOf(0));
}
public boolean long___nonzero__() {
return __nonzero__();
}
public double doubleValue() {
double v = value.doubleValue();
if (v == Double.NEGATIVE_INFINITY || v == Double.POSITIVE_INFINITY) {
throw Py.OverflowError("long int too long to convert");
}
return v;
}
private static final double scaledDoubleValue(BigInteger val, int[] exp){
double x = 0;
int signum = val.signum();
byte[] digits;
if (signum >= 0) {
digits = val.toByteArray();
} else {
digits = val.negate().toByteArray();
}
int count = 8;
int i = 0;
if (digits[0] == 0) {
i++;
count++;
}
count = count <= digits.length?count:digits.length;
while (i < count) {
x = x * 256 + (digits[i] & 0xff);
i++;
}
exp[0] = digits.length - i;
return signum*x;
}
public double scaledDoubleValue(int[] exp){
return scaledDoubleValue(value,exp);
}
private long getLong(long min, long max) {
if (value.compareTo(maxLong) <= 0 && value.compareTo(minLong) >= 0) {
long v = value.longValue();
if (v >= min && v <= max)
return v;
}
throw Py.OverflowError("long int too long to convert");
}
public long asLong(int index) {
return getLong(Long.MIN_VALUE, Long.MAX_VALUE);
}
public Object __tojava__(Class c) {
try {
if (c == Byte.TYPE || c == Byte.class) {
return new Byte((byte)getLong(Byte.MIN_VALUE,
Byte.MAX_VALUE));
}
if (c == Short.TYPE || c == Short.class) {
return new Short((short)getLong(Short.MIN_VALUE,
Short.MAX_VALUE));
}
if (c == Integer.TYPE || c == Integer.class) {
return new Integer((int)getLong(Integer.MIN_VALUE,
Integer.MAX_VALUE));
}
if (c == Long.TYPE || c == Long.class) {
return new Long(getLong(Long.MIN_VALUE,
Long.MAX_VALUE));
}
if (c == Float.TYPE || c == Double.TYPE || c == Float.class ||
c == Double.class)
{
return __float__().__tojava__(c);
}
if (c == BigInteger.class || c == Number.class ||
c == Object.class || c == Serializable.class)
{
return value;
}
} catch (PyException e) {
return Py.NoConversion;
}
return super.__tojava__(c);
}
public int __cmp__(PyObject other) {
return long___cmp__(other);
}
final int long___cmp__(PyObject other) {
if (!canCoerce(other))
return -2;
return value.compareTo(coerce(other));
}
public Object __coerce_ex__(PyObject other) {
if (other instanceof PyLong)
return other;
else
if (other instanceof PyInteger) {
return Py.newLong(((PyInteger)other).getValue());
} else {
return Py.None;
}
}
private static final boolean canCoerce(PyObject other) {
return other instanceof PyLong || other instanceof PyInteger;
}
private static final BigInteger coerce(PyObject other) {
if (other instanceof PyLong)
return ((PyLong) other).value;
else if (other instanceof PyInteger)
return BigInteger.valueOf(
((PyInteger) other).getValue());
else
throw Py.TypeError("xxx");
}
public PyObject __add__(PyObject right) {
return long___add__(right);
}
final PyObject long___add__(PyObject right) {
if (!canCoerce(right))
return null;
return Py.newLong(value.add(coerce(right)));
}
public PyObject __radd__(PyObject left) {
return long___radd__(left);
}
final PyObject long___radd__(PyObject left) {
return __add__(left);
}
public PyObject __sub__(PyObject right) {
return long___sub__(right);
}
final PyObject long___sub__(PyObject right) {
if (!canCoerce(right))
return null;
return Py.newLong(value.subtract(coerce(right)));
}
public PyObject __rsub__(PyObject left) {
return long___rsub__(left);
}
final PyObject long___rsub__(PyObject left) {
return Py.newLong(coerce(left).subtract(value));
}
public PyObject __mul__(PyObject right) {
return long___mul__(right);
}
final PyObject long___mul__(PyObject right) {
if (right instanceof PySequence)
return ((PySequence) right).repeat(coerceInt(this));
if (!canCoerce(right))
return null;
return Py.newLong(value.multiply(coerce(right)));
}
public PyObject __rmul__(PyObject left) {
return long___rmul__(left);
}
final PyObject long___rmul__(PyObject left) {
if (left instanceof PySequence)
return ((PySequence) left).repeat(coerceInt(this));
if (!canCoerce(left))
return null;
return Py.newLong(coerce(left).multiply(value));
}
// Getting signs correct for integer division
// This convention makes sense when you consider it in tandem with modulo
private BigInteger divide(BigInteger x, BigInteger y) {
BigInteger zero = BigInteger.valueOf(0);
if (y.equals(zero))
throw Py.ZeroDivisionError("long division or modulo");
if (y.compareTo(zero) < 0) {
if (x.compareTo(zero) > 0)
return (x.subtract(y).subtract(
BigInteger.valueOf(1))).divide(y);
} else {
if (x.compareTo(zero) < 0)
return (x.subtract(y).add(BigInteger.valueOf(1))).divide(y);
}
return x.divide(y);
}
public PyObject __div__(PyObject right) {
return long___div__(right);
}
final PyObject long___div__(PyObject right) {
if (!canCoerce(right))
return null;
if (Options.divisionWarning > 0)
Py.warning(Py.DeprecationWarning, "classic long division");
return Py.newLong(divide(value, coerce(right)));
}
public PyObject __rdiv__(PyObject left) {
return long___rdiv__(left);
}
final PyObject long___rdiv__(PyObject left) {
if (!canCoerce(left))
return null;
if (Options.divisionWarning > 0)
Py.warning(Py.DeprecationWarning, "classic long division");
return Py.newLong(divide(coerce(left), value));
}
public PyObject __floordiv__(PyObject right) {
return long___floordiv__(right);
}
final PyObject long___floordiv__(PyObject right) {
if (!canCoerce(right))
return null;
return Py.newLong(divide(value, coerce(right)));
}
public PyObject __rfloordiv__(PyObject left) {
return long___rfloordiv__(left);
}
final PyObject long___rfloordiv__(PyObject left) {
if (!canCoerce(left))
return null;
return Py.newLong(divide(coerce(left), value));
}
private static final PyFloat true_divide(BigInteger a,BigInteger b) {
int[] ae = new int[1];
int[] be = new int[1];
double ad,bd;
ad = scaledDoubleValue(a,ae);
bd = scaledDoubleValue(b,be);
if (bd == 0 ) throw Py.ZeroDivisionError("long division or modulo");
ad /= bd;
int aexp = ae[0]-be[0];
if (aexp > Integer.MAX_VALUE/8) {
throw Py.OverflowError("long/long too large for a float");
} else if ( aexp < -(Integer.MAX_VALUE/8)) {
return new PyFloat(0.0);
}
ad = ad * Math.pow(2.0, aexp*8);
if (Double.isInfinite(ad)) {
throw Py.OverflowError("long/long too large for a float");
}
return new PyFloat(ad);
}
public PyObject __truediv__(PyObject right) {
return long___truediv__(right);
}
final PyObject long___truediv__(PyObject right) {
if (!canCoerce(right))
return null;
return true_divide(this.value,coerce(right));
}
public PyObject __rtruediv__(PyObject left) {
return long___rtruediv__(left);
}
final PyObject long___rtruediv__(PyObject left) {
if (!canCoerce(left))
return null;
return true_divide(coerce(left),this.value);
}
private BigInteger modulo(BigInteger x, BigInteger y, BigInteger xdivy) {
return x.subtract(xdivy.multiply(y));
}
public PyObject __mod__(PyObject right) {
return long___mod__(right);
}
final PyObject long___mod__(PyObject right) {
if (!canCoerce(right))
return null;
BigInteger rightv = coerce(right);
return Py.newLong(modulo(value, rightv, divide(value, rightv)));
}
public PyObject __rmod__(PyObject left) {
return long___rmod__(left);
}
final PyObject long___rmod__(PyObject left) {
if (!canCoerce(left))
return null;
BigInteger leftv = coerce(left);
return Py.newLong(modulo(leftv, value, divide(leftv, value)));
}
public PyObject __divmod__(PyObject right) {
return long___divmod__(right);
}
final PyObject long___divmod__(PyObject right) {
if (!canCoerce(right))
return null;
BigInteger rightv = coerce(right);
BigInteger xdivy = divide(value, rightv);
return new PyTuple(new PyObject[] {
Py.newLong(xdivy),
Py.newLong(modulo(value, rightv, xdivy))
});
}
public PyObject __rdivmod__(PyObject left) {
return long___rdivmod__(left);
}
final PyObject long___rdivmod__(PyObject left) {
if (!canCoerce(left))
return null;
BigInteger leftv = coerce(left);
BigInteger xdivy = divide(leftv, value);
return new PyTuple(new PyObject[] {
Py.newLong(xdivy),
Py.newLong(modulo(leftv, value, xdivy))
});
}
public PyObject __pow__(PyObject right, PyObject modulo) {
return long___pow__(right, modulo);
}
final PyObject long___pow__(PyObject right, PyObject modulo) {
if (!canCoerce(right))
return null;
if (modulo != null && !canCoerce(right))
return null;
return _pow(value, coerce(right), modulo, this, right);
}
public PyObject __rpow__(PyObject left) {
return long___rpow__(left);
}
final PyObject long___rpow__(PyObject left) {
if (!canCoerce(left))
return null;
return _pow(coerce(left), value, null, left, this);
}
public static PyObject _pow(BigInteger value, BigInteger y,
PyObject modulo, PyObject left, PyObject right)
{
if (y.compareTo(BigInteger.valueOf(0)) < 0) {
if (value.compareTo(BigInteger.valueOf(0)) != 0)
return left.__float__().__pow__(right, modulo);
else
throw Py.ZeroDivisionError("zero to a negative power");
}
if (modulo == null)
return Py.newLong(value.pow(y.intValue()));
else {
// This whole thing can be trivially rewritten after bugs
// in modPow are fixed by SUN
BigInteger z = coerce(modulo);
int zi = z.intValue();
// Clear up some special cases right away
if (zi == 0)
throw Py.ValueError("pow(x, y, z) with z == 0");
if (zi == 1 || zi == -1)
return Py.newLong(0);
if (z.compareTo(BigInteger.valueOf(0)) <= 0) {
// Handle negative modulo's specially
/*if (z.compareTo(BigInteger.valueOf(0)) == 0) {
throw Py.ValueError("pow(x, y, z) with z == 0");
}*/
y = value.modPow(y, z.negate());
if (y.compareTo(BigInteger.valueOf(0)) > 0) {
return Py.newLong(z.add(y));
} else {
return Py.newLong(y);
}
//return __pow__(right).__mod__(modulo);
} else {
// XXX: 1.1 no longer supported so review this.
// This is buggy in SUN's jdk1.1.5
// Extra __mod__ improves things slightly
return Py.newLong(value.modPow(y, z));
//return __pow__(right).__mod__(modulo);
}
}
}
private static final int coerceInt(PyObject other) {
if (other instanceof PyLong)
return (int) ((PyLong) other).getLong(
Integer.MIN_VALUE, Integer.MAX_VALUE);
else if (other instanceof PyInteger)
return ((PyInteger) other).getValue();
else
throw Py.TypeError("xxx");
}
public PyObject __lshift__(PyObject right) {
return long___lshift__(right);
}
final PyObject long___lshift__(PyObject right) {
if (!canCoerce(right))
return null;
int rightv = coerceInt(right);
if(rightv < 0)
throw Py.ValueError("negative shift count");
return Py.newLong(value.shiftLeft(rightv));
}
final PyObject long___rlshift__(PyObject left) {
if (!canCoerce(left))
return null;
if(value.intValue() < 0)
throw Py.ValueError("negative shift count");
return Py.newLong(coerce(left).shiftLeft(coerceInt(this)));
}
public PyObject __rshift__(PyObject right) {
return long___rshift__(right);
}
final PyObject long___rshift__(PyObject right) {
if (!canCoerce(right))
return null;
int rightv = coerceInt(right);
if(rightv < 0)
throw Py.ValueError("negative shift count");
return Py.newLong(value.shiftRight(rightv));
}
final PyObject long___rrshift__(PyObject left) {
if (!canCoerce(left))
return null;
if(value.intValue() < 0)
throw Py.ValueError("negative shift count");
return Py.newLong(coerce(left).shiftRight(coerceInt(this)));
}
public PyObject __and__(PyObject right) {
return long___and__(right);
}
final PyObject long___and__(PyObject right) {
if (!canCoerce(right))
return null;
return Py.newLong(value.and(coerce(right)));
}
public PyObject __rand__(PyObject left) {
return long___rand__(left);
}
final PyObject long___rand__(PyObject left) {
if (!canCoerce(left))
return null;
return Py.newLong(coerce(left).and(value));
}
public PyObject __xor__(PyObject right) {
return long___xor__(right);
}
final PyObject long___xor__(PyObject right) {
if (!canCoerce(right))
return null;
return Py.newLong(value.xor(coerce(right)));
}
public PyObject __rxor__(PyObject left) {
return long___rxor__(left);
}
final PyObject long___rxor__(PyObject left) {
if (!canCoerce(left))
return null;
return Py.newLong(coerce(left).xor(value));
}
public PyObject __or__(PyObject right) {
return long___or__(right);
}
final PyObject long___or__(PyObject right) {
if (!canCoerce(right))
return null;
return Py.newLong(value.or(coerce(right)));
}
public PyObject __ror__(PyObject left) {
return long___ror__(left);
}
final PyObject long___ror__(PyObject left) {
if (!canCoerce(left))
return null;
return Py.newLong(coerce(left).or(value));
}
public PyObject __neg__() {
return long___neg__();
}
final PyObject long___neg__() {
return Py.newLong(value.negate());
}
public PyObject __pos__() {
return long___pos__();
}
final PyObject long___pos__() {
return Py.newLong(value);
}
public PyObject __abs__() {
return long___abs__();
}
final PyObject long___abs__() {
return Py.newLong(value.abs());
}
public PyObject __invert__() {
return long___invert__();
}
final PyObject long___invert__() {
return Py.newLong(value.not());
}
public PyObject __int__() {
return long___int__();
}
final PyObject long___int__() {
long v = value.longValue();
if (v < Integer.MIN_VALUE || v > Integer.MAX_VALUE) {
return Py.newLong(value);
}
return Py.newInteger((int)getLong(Integer.MIN_VALUE,
Integer.MAX_VALUE));
}
public PyLong __long__() {
return long___long__();
}
final PyLong long___long__() {
return Py.newLong(value);
}
public PyFloat __float__() {
return long___float__();
}
final PyFloat long___float__() {
return new PyFloat(doubleValue());
}
public PyComplex __complex__() {
return long___complex__();
}
final PyComplex long___complex__() {
return new PyComplex(doubleValue(), 0.);
}
public PyString __oct__() {
return long___oct__();
}
final PyString long___oct__() {
String s = value.toString(8);
if (s.startsWith("-"))
return new PyString("-0"+s.substring(1, s.length())+"L");
else
if (s.startsWith("0"))
return new PyString(s+"L");
else
return new PyString("0"+s+"L");
}
public PyString __hex__() {
return long___hex__();
}
final PyString long___hex__() {
String s = value.toString(16).toUpperCase();
if (s.startsWith("-"))
return new PyString("-0x"+s.substring(1, s.length())+"L");
else
return new PyString("0x"+s+"L");
}
public PyString __str__() {
return Py.newString(value.toString());
}
public PyUnicode __unicode__() {
return new PyUnicode(value.toString());
}
public boolean isMappingType() { return false; }
public boolean isSequenceType() { return false; }
}
