// Copyright (c) Corporation for National Research Initiatives
package org.python.core;
import java.io.Serializable;
/**
* A builtin python float.
*/
public class PyFloat extends PyObject {
//~ BEGIN GENERATED REGION -- DO NOT EDIT SEE gexpose.py
/* type info */
public static final String exposed_name = "float";
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 ((PyFloat) self).float___abs__();
}
}
dict.__setitem__("__abs__", new PyMethodDescr("__abs__", PyFloat.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 ((PyFloat) self).float___float__();
}
}
dict.__setitem__("__float__", new PyMethodDescr("__float__", PyFloat.class, 0, 0, new exposed___float__(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 ((PyFloat) self).float___int__();
}
}
dict.__setitem__("__int__", new PyMethodDescr("__int__", PyFloat.class, 0, 0, new exposed___int__(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 ((PyFloat) self).float___long__();
}
}
dict.__setitem__("__long__", new PyMethodDescr("__long__", PyFloat.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 ((PyFloat) self).float___neg__();
}
}
dict.__setitem__("__neg__", new PyMethodDescr("__neg__", PyFloat.class, 0, 0, new exposed___neg__(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 ((PyFloat) self).float___pos__();
}
}
dict.__setitem__("__pos__", new PyMethodDescr("__pos__", PyFloat.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 = ((PyFloat) self).float___add__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__add__", new PyMethodDescr("__add__", PyFloat.class, 1, 1, new exposed___add__(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 = ((PyFloat) self).float___div__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__div__", new PyMethodDescr("__div__", PyFloat.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 = ((PyFloat) self).float___divmod__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__divmod__", new PyMethodDescr("__divmod__", PyFloat.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 = ((PyFloat) self).float___floordiv__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__floordiv__", new PyMethodDescr("__floordiv__", PyFloat.class, 1, 1,
new exposed___floordiv__(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 = ((PyFloat) self).float___mod__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__mod__", new PyMethodDescr("__mod__", PyFloat.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 = ((PyFloat) self).float___mul__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__mul__", new PyMethodDescr("__mul__", PyFloat.class, 1, 1, new exposed___mul__(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 = ((PyFloat) self).float___radd__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__radd__", new PyMethodDescr("__radd__", PyFloat.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 = ((PyFloat) self).float___rdiv__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rdiv__", new PyMethodDescr("__rdiv__", PyFloat.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 = ((PyFloat) self).float___rfloordiv__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rfloordiv__", new PyMethodDescr("__rfloordiv__", PyFloat.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 = ((PyFloat) self).float___rmod__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rmod__", new PyMethodDescr("__rmod__", PyFloat.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 = ((PyFloat) self).float___rmul__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rmul__", new PyMethodDescr("__rmul__", PyFloat.class, 1, 1,
new exposed___rmul__(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 = ((PyFloat) self).float___rsub__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rsub__", new PyMethodDescr("__rsub__", PyFloat.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 = ((PyFloat) self).float___rtruediv__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rtruediv__", new PyMethodDescr("__rtruediv__", PyFloat.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 = ((PyFloat) self).float___sub__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__sub__", new PyMethodDescr("__sub__", PyFloat.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 = ((PyFloat) self).float___truediv__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__truediv__", new PyMethodDescr("__truediv__", PyFloat.class, 1, 1, new exposed___truediv__(
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 = ((PyFloat) self).float___rdivmod__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rdivmod__", new PyMethodDescr("__rdivmod__", PyFloat.class, 1, 1, new exposed___rdivmod__(
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 = ((PyFloat) self).float___rpow__(arg0);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__rpow__", new PyMethodDescr("__rpow__", PyFloat.class, 1, 1,
new exposed___rpow__(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 = ((PyFloat) self).float___cmp__(arg0);
if (ret == -2) {
throw Py.TypeError("float" + ".__cmp__(x,y) requires y to be '" + "float" + "', not a '"
+ (arg0).getType().fastGetName() + "'");
}
return Py.newInteger(ret);
}
}
dict.__setitem__("__cmp__", new PyMethodDescr("__cmp__", PyFloat.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 = ((PyFloat) self).float___pow__(arg0, arg1);
if (ret == null)
return Py.NotImplemented;
return ret;
}
public PyObject __call__(PyObject arg0) {
PyObject ret = ((PyFloat) self).float___pow__(arg0, null);
if (ret == null)
return Py.NotImplemented;
return ret;
}
}
dict.__setitem__("__pow__", new PyMethodDescr("__pow__", PyFloat.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(((PyFloat) self).float___nonzero__());
}
}
dict.__setitem__("__nonzero__", new PyMethodDescr("__nonzero__", PyFloat.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(((PyFloat) self).float_toString());
}
}
dict.__setitem__("__repr__", new PyMethodDescr("__repr__", PyFloat.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(((PyFloat) self).float_toString());
}
}
dict.__setitem__("__str__", new PyMethodDescr("__str__", PyFloat.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(((PyFloat) self).float_hashCode());
}
}
dict.__setitem__("__hash__", new PyMethodDescr("__hash__", PyFloat.class, 0, 0,
new exposed___hash__(null, null)));
dict.__setitem__("__new__", new PyNewWrapper(PyFloat.class, "__new__", -1, -1) {
public PyObject new_impl(boolean init, PyType subtype, PyObject[] args, String[] keywords) {
return float_new(this, init, subtype, args, keywords);
}
});
}
//~ END GENERATED REGION -- DO NOT EDIT SEE gexpose.py
public static PyObject float_new(PyNewWrapper new_, boolean init, PyType subtype, PyObject[] args, String[] keywords) {
ArgParser ap = new ArgParser("float", args, keywords, new String[] { "x" }, 0);
PyObject x = ap.getPyObject(0, null);
if (new_.for_type == subtype) {
if (x == null) {
return new PyFloat(0.0);
}
return x.__float__();
} else {
if (x == null) {
return new PyFloatDerived(subtype, 0.0);
}
return new PyFloatDerived(subtype, x.__float__().getValue());
}
} // xxx
private static final PyType FLOATTYPE = PyType.fromClass(PyFloat.class);
private double value;
public PyFloat(PyType subtype, double v) {
super(subtype);
value = v;
}
public PyFloat(double v) {
this(FLOATTYPE, v);
}
public PyFloat(float v) {
this((double) v);
}
public String safeRepr() throws PyIgnoreMethodTag {
return "'float' object";
}
public double getValue() {
return value;
}
public String toString() {
return float_toString();
}
final String float_toString() {
String s = Double.toString(value);
// this is to work around an apparent bug in Double.toString(0.001)
// which returns "0.0010"
if (s.indexOf('E') == -1) {
while (true) {
int n = s.length();
if (n <= 2)
break;
if (s.charAt(n - 1) == '0' && s.charAt(n - 2) != '.') {
s = s.substring(0, n - 1);
continue;
}
break;
}
}
return s;
}
public int hashCode() {
return float_hashCode();
}
final int float_hashCode() {
double intPart = Math.floor(value);
double fractPart = value - intPart;
if (fractPart == 0) {
if (intPart <= Integer.MAX_VALUE && intPart >= Integer.MIN_VALUE)
return (int) value;
else
return __long__().hashCode();
} else {
long v = Double.doubleToLongBits(value);
return (int) v ^ (int) (v >> 32);
}
}
public boolean __nonzero__() {
return float___nonzero__();
}
final boolean float___nonzero__() {
return value != 0;
}
public Object __tojava__(Class c) {
if (c == Double.TYPE || c == Number.class || c == Double.class || c == Object.class || c == Serializable.class) {
return new Double(value);
}
if (c == Float.TYPE || c == Float.class) {
return new Float(value);
}
return super.__tojava__(c);
}
public int __cmp__(PyObject other) {
return float___cmp__(other);
}
final int float___cmp__(PyObject other) {
if (!canCoerce(other))
return -2;
double v = coerce(other);
return value < v ? -1 : value > v ? 1 : 0;
}
public Object __coerce_ex__(PyObject other) {
if (other instanceof PyFloat)
return other;
else {
if (other instanceof PyInteger)
return new PyFloat((double) ((PyInteger) other).getValue());
if (other instanceof PyLong)
return new PyFloat(((PyLong) other).doubleValue());
else
return Py.None;
}
}
private static final boolean canCoerce(PyObject other) {
return other instanceof PyFloat || other instanceof PyInteger || other instanceof PyLong;
}
private static final double coerce(PyObject other) {
if (other instanceof PyFloat)
return ((PyFloat) other).value;
else if (other instanceof PyInteger)
return ((PyInteger) other).getValue();
else if (other instanceof PyLong)
return ((PyLong) other).doubleValue();
else
throw Py.TypeError("xxx");
}
public PyObject __add__(PyObject right) {
return float___add__(right);
}
final PyObject float___add__(PyObject right) {
if (!canCoerce(right))
return null;
double rightv = coerce(right);
return new PyFloat(value + rightv);
}
public PyObject __radd__(PyObject left) {
return float___radd__(left);
}
final PyObject float___radd__(PyObject left) {
return __add__(left);
}
public PyObject __sub__(PyObject right) {
return float___sub__(right);
}
final PyObject float___sub__(PyObject right) {
if (!canCoerce(right))
return null;
double rightv = coerce(right);
return new PyFloat(value - rightv);
}
public PyObject __rsub__(PyObject left) {
return float___rsub__(left);
}
final PyObject float___rsub__(PyObject left) {
if (!canCoerce(left))
return null;
double leftv = coerce(left);
return new PyFloat(leftv - value);
}
public PyObject __mul__(PyObject right) {
return float___mul__(right);
}
final PyObject float___mul__(PyObject right) {
if (!canCoerce(right))
return null;
double rightv = coerce(right);
return new PyFloat(value * rightv);
}
public PyObject __rmul__(PyObject left) {
return float___rmul__(left);
}
final PyObject float___rmul__(PyObject left) {
return __mul__(left);
}
public PyObject __div__(PyObject right) {
return float___div__(right);
}
final PyObject float___div__(PyObject right) {
if (!canCoerce(right))
return null;
if (Options.divisionWarning >= 2)
Py.warning(Py.DeprecationWarning, "classic float division");
double rightv = coerce(right);
if (rightv == 0)
throw Py.ZeroDivisionError("float division");
return new PyFloat(value / rightv);
}
public PyObject __rdiv__(PyObject left) {
return float___rdiv__(left);
}
final PyObject float___rdiv__(PyObject left) {
if (!canCoerce(left))
return null;
if (Options.divisionWarning >= 2)
Py.warning(Py.DeprecationWarning, "classic float division");
double leftv = coerce(left);
if (value == 0)
throw Py.ZeroDivisionError("float division");
return new PyFloat(leftv / value);
}
public PyObject __floordiv__(PyObject right) {
return float___floordiv__(right);
}
final PyObject float___floordiv__(PyObject right) {
if (!canCoerce(right))
return null;
double rightv = coerce(right);
if (rightv == 0)
throw Py.ZeroDivisionError("float division");
return new PyFloat(Math.floor(value / rightv));
}
public PyObject __rfloordiv__(PyObject left) {
return float___rfloordiv__(left);
}
final PyObject float___rfloordiv__(PyObject left) {
if (!canCoerce(left))
return null;
double leftv = coerce(left);
if (value == 0)
throw Py.ZeroDivisionError("float division");
return new PyFloat(Math.floor(leftv / value));
}
public PyObject __truediv__(PyObject right) {
return float___truediv__(right);
}
final PyObject float___truediv__(PyObject right) {
if (!canCoerce(right))
return null;
double rightv = coerce(right);
if (rightv == 0)
throw Py.ZeroDivisionError("float division");
return new PyFloat(value / rightv);
}
public PyObject __rtruediv__(PyObject left) {
return float___rtruediv__(left);
}
final PyObject float___rtruediv__(PyObject left) {
if (!canCoerce(left))
return null;
double leftv = coerce(left);
if (value == 0)
throw Py.ZeroDivisionError("float division");
return new PyFloat(leftv / value);
}
private static double modulo(double x, double y) {
if (y == 0)
throw Py.ZeroDivisionError("float modulo");
double z = Math.IEEEremainder(x, y);
if (z * y < 0)
z += y;
return z;
}
public PyObject __mod__(PyObject right) {
return float___mod__(right);
}
final PyObject float___mod__(PyObject right) {
if (!canCoerce(right))
return null;
double rightv = coerce(right);
return new PyFloat(modulo(value, rightv));
}
public PyObject __rmod__(PyObject left) {
return float___rmod__(left);
}
final PyObject float___rmod__(PyObject left) {
if (!canCoerce(left))
return null;
double leftv = coerce(left);
return new PyFloat(modulo(leftv, value));
}
public PyObject __divmod__(PyObject right) {
return float___divmod__(right);
}
final PyObject float___divmod__(PyObject right) {
if (!canCoerce(right))
return null;
double rightv = coerce(right);
if (rightv == 0)
throw Py.ZeroDivisionError("float division");
double z = Math.floor(value / rightv);
return new PyTuple(new PyObject[] { new PyFloat(z), new PyFloat(value - z * rightv) });
}
public PyObject __rdivmod__(PyObject left) {
if (!canCoerce(left))
return null;
double leftv = coerce(left);
if (value == 0)
throw Py.ZeroDivisionError("float division");
double z = Math.floor(leftv / value);
return new PyTuple(new PyObject[] { new PyFloat(z), new PyFloat(leftv - z * value) });
}
final PyObject float___rdivmod__(PyObject left) {
return __rdivmod__(left);
}
public PyObject __pow__(PyObject right, PyObject modulo) {
return float___pow__(right, modulo);
}
final PyObject float___pow__(PyObject right, PyObject modulo) {
if (!canCoerce(right))
return null;
if (modulo != null) {
throw Py.TypeError("pow() 3rd argument not allowed " + "unless all arguments are integers");
}
return _pow(value, coerce(right), modulo);
}
final PyObject float___rpow__(PyObject left) {
return __rpow__(left);
}
public PyObject __rpow__(PyObject left) {
if (!canCoerce(left))
return null;
return _pow(coerce(left), value, null);
}
private static PyFloat _pow(double value, double iw, PyObject modulo) {
// Rely completely on Java's pow function
if (iw == 0) {
if (modulo != null)
return new PyFloat(modulo(1.0, coerce(modulo)));
return new PyFloat(1.0);
}
if (value == 0.0) {
if (iw < 0.0)
throw Py.ZeroDivisionError("0.0 cannot be raised to a " + "negative power");
return new PyFloat(0);
}
if (value < 0 && iw != Math.floor(iw))
throw Py.ValueError("negative number cannot be raised to a fractional power");
double ret = Math.pow(value, iw);
if (modulo == null) {
return new PyFloat(ret);
} else {
return new PyFloat(modulo(ret, coerce(modulo)));
}
}
public PyObject __neg__() {
return float___neg__();
}
final PyObject float___neg__() {
return new PyFloat(-value);
}
public PyObject __pos__() {
return float___pos__();
}
final PyObject float___pos__() {
return Py.newFloat(value);
}
public PyObject __invert__() {
throw Py.TypeError("bad operand type for unary ~");
}
public PyObject __abs__() {
return float___abs__();
}
final PyObject float___abs__() {
if (value >= 0)
return Py.newFloat(value);
else
return __neg__();
}
public PyObject __int__() {
return float___int__();
}
final PyInteger float___int__() {
if (value <= Integer.MAX_VALUE && value >= Integer.MIN_VALUE) {
return new PyInteger((int) value);
}
throw Py.OverflowError("float too large to convert");
}
public PyLong __long__() {
return float___long__();
}
final PyLong float___long__() {
return new PyLong(value);
}
public PyFloat __float__() {
return float___float__();
}
final PyFloat float___float__() {
return Py.newFloat(value);
}
public PyComplex __complex__() {
return new PyComplex(value, 0.);
}
public boolean isMappingType() throws PyIgnoreMethodTag {
return false;
}
public boolean isSequenceType() throws PyIgnoreMethodTag {
return false;
}
}