Skip to content

P
Pyston
Commit 19db347a authored by Kevin Modzelewski's avatar Kevin Modzelewski
Browse files
Options

Merge commit '91cd46' into refcounting

parents 58366391 91cd46b6
Hide whitespace changes
Inline Side-by-side
Showing with 102 additions and 159 deletions
src/runtime/builtin_modules/builtins.cpp
View file @ 19db347a
......@@ -1873,6 +1873,7 @@ void setupBuiltins() {
notimplemented_cls->giveAttr("__repr__",
new BoxedFunction(FunctionMetadata::create((void*)notimplementedRepr, STR, 1)));
notimplemented_cls->freeze();
notimplemented_cls->instances_are_nonzero = true;
NotImplemented = new (notimplemented_cls) Box();
constants.push_back(NotImplemented);
......
src/runtime/float.cpp
View file @ 19db347a
......@@ -115,24 +115,24 @@ extern "C" double floordiv_float_float(double lhs, double rhs) {
}
extern "C" Box* floatAddFloat(BoxedFloat* lhs, BoxedFloat* rhs) {
assert(lhs->cls == float_cls);
assert(rhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyFloat_Check(rhs));
return boxFloat(lhs->d + rhs->d);
}
extern "C" Box* floatAddInt(BoxedFloat* lhs, BoxedInt* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyInt_Check(rhs));
return boxFloat(lhs->d + rhs->n);
}
extern "C" Box* floatAdd(BoxedFloat* lhs, Box* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
if (PyInt_Check(rhs)) {
return floatAddInt(lhs, static_cast<BoxedInt*>(rhs));
} else if (rhs->cls == float_cls) {
} else if (PyFloat_Check(rhs)) {
return floatAddFloat(lhs, static_cast<BoxedFloat*>(rhs));
} else if (rhs->cls == long_cls) {
} else if (PyLong_Check(rhs)) {
double rhs_f = PyLong_AsDouble(rhs);
if (rhs_f == -1.0 && PyErr_Occurred()) {
throwCAPIException();
......@@ -144,26 +144,26 @@ extern "C" Box* floatAdd(BoxedFloat* lhs, Box* rhs) {
}
extern "C" Box* floatDivFloat(BoxedFloat* lhs, BoxedFloat* rhs) {
assert(lhs->cls == float_cls);
assert(rhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyFloat_Check(rhs));
raiseDivZeroExcIfZero(rhs->d);
return boxFloat(lhs->d / rhs->d);
}
extern "C" Box* floatDivInt(BoxedFloat* lhs, BoxedInt* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyInt_Check(rhs));
raiseDivZeroExcIfZero(rhs->n);
return boxFloat(lhs->d / rhs->n);
}
extern "C" Box* floatDiv(BoxedFloat* lhs, Box* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
if (PyInt_Check(rhs)) {
return floatDivInt(lhs, static_cast<BoxedInt*>(rhs));
} else if (rhs->cls == float_cls) {
} else if (PyFloat_Check(rhs)) {
return floatDivFloat(lhs, static_cast<BoxedFloat*>(rhs));
} else if (rhs->cls == long_cls) {
} else if (PyLong_Check(rhs)) {
double rhs_f = PyLong_AsDouble(rhs);
if (rhs_f == -1.0 && PyErr_Occurred()) {
throwCAPIException();
......@@ -175,12 +175,12 @@ extern "C" Box* floatDiv(BoxedFloat* lhs, Box* rhs) {
}
extern "C" Box* floatTruediv(BoxedFloat* lhs, Box* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
if (PyInt_Check(rhs)) {
return floatDivInt(lhs, static_cast<BoxedInt*>(rhs));
} else if (rhs->cls == float_cls) {
} else if (PyFloat_Check(rhs)) {
return floatDivFloat(lhs, static_cast<BoxedFloat*>(rhs));
} else if (rhs->cls == long_cls) {
} else if (PyLong_Check(rhs)) {
double rhs_f = PyLong_AsDouble(rhs);
if (rhs_f == -1.0 && PyErr_Occurred()) {
throwCAPIException();
......@@ -192,26 +192,26 @@ extern "C" Box* floatTruediv(BoxedFloat* lhs, Box* rhs) {
}
extern "C" Box* floatRDivFloat(BoxedFloat* lhs, BoxedFloat* rhs) {
assert(lhs->cls == float_cls);
assert(rhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyFloat_Check(rhs));
raiseDivZeroExcIfZero(lhs->d);
return boxFloat(rhs->d / lhs->d);
}
extern "C" Box* floatRDivInt(BoxedFloat* lhs, BoxedInt* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyInt_Check(rhs));
raiseDivZeroExcIfZero(lhs->d);
return boxFloat(rhs->n / lhs->d);
}
extern "C" Box* floatRDiv(BoxedFloat* lhs, Box* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
if (PyInt_Check(rhs)) {
return floatRDivInt(lhs, static_cast<BoxedInt*>(rhs));
} else if (rhs->cls == float_cls) {
} else if (PyFloat_Check(rhs)) {
return floatRDivFloat(lhs, static_cast<BoxedFloat*>(rhs));
} else if (rhs->cls == long_cls) {
} else if (PyLong_Check(rhs)) {
double rhs_f = PyLong_AsDouble(rhs);
if (rhs_f == -1.0 && PyErr_Occurred()) {
throwCAPIException();
......@@ -245,26 +245,26 @@ Box* floatRTruediv(BoxedFloat* lhs, Box* rhs) {
}
extern "C" Box* floatFloorDivFloat(BoxedFloat* lhs, BoxedFloat* rhs) {
assert(lhs->cls == float_cls);
assert(rhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyFloat_Check(rhs));
raiseDivZeroExcIfZero(rhs->d);
return boxFloat(floor(lhs->d / rhs->d));
}
extern "C" Box* floatFloorDivInt(BoxedFloat* lhs, BoxedInt* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyInt_Check(rhs));
raiseDivZeroExcIfZero(rhs->n);
return boxFloat(floor(lhs->d / rhs->n));
}
extern "C" Box* floatFloorDiv(BoxedFloat* lhs, Box* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
if (PyInt_Check(rhs)) {
return floatFloorDivInt(lhs, static_cast<BoxedInt*>(rhs));
} else if (rhs->cls == float_cls) {
} else if (PyFloat_Check(rhs)) {
return floatFloorDivFloat(lhs, static_cast<BoxedFloat*>(rhs));
} else if (rhs->cls == long_cls) {
} else if (PyLong_Check(rhs)) {
double rhs_f = PyLong_AsDouble(rhs);
if (rhs_f == -1.0 && PyErr_Occurred()) {
throwCAPIException();
......@@ -276,16 +276,16 @@ extern "C" Box* floatFloorDiv(BoxedFloat* lhs, Box* rhs) {
}
extern "C" Box* floatRFloorDiv(BoxedFloat* lhs, Box* _rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
if (PyInt_Check(_rhs)) {
BoxedInt* rhs = (BoxedInt*)_rhs;
raiseDivZeroExcIfZero(lhs->d);
return boxFloat(floor(rhs->n / lhs->d));
} else if (_rhs->cls == float_cls) {
} else if (PyFloat_Check(_rhs)) {
BoxedFloat* rhs = (BoxedFloat*)_rhs;
raiseDivZeroExcIfZero(lhs->d);
return boxFloat(floor(rhs->d / lhs->d));
} else if (_rhs->cls == long_cls) {
} else if (PyLong_Check(_rhs)) {
double rhs_f = PyLong_AsDouble(_rhs);
if (rhs_f == -1.0 && PyErr_Occurred()) {
throwCAPIException();
......@@ -599,24 +599,24 @@ extern "C" Box* floatGt(BoxedFloat* lhs, Box* rhs) {
}
extern "C" Box* floatModFloat(BoxedFloat* lhs, BoxedFloat* rhs) {
assert(lhs->cls == float_cls);
assert(rhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyFloat_Check(rhs));
return boxFloat(mod_float_float(lhs->d, rhs->d));
}
extern "C" Box* floatModInt(BoxedFloat* lhs, BoxedInt* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyInt_Check(rhs));
return boxFloat(mod_float_float(lhs->d, rhs->n));
}
extern "C" Box* floatMod(BoxedFloat* lhs, Box* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
if (PyInt_Check(rhs)) {
return floatModInt(lhs, static_cast<BoxedInt*>(rhs));
} else if (rhs->cls == float_cls) {
} else if (PyFloat_Check(rhs)) {
return floatModFloat(lhs, static_cast<BoxedFloat*>(rhs));
} else if (rhs->cls == long_cls) {
} else if (PyLong_Check(rhs)) {
double rhs_f = PyLong_AsDouble(rhs);
if (rhs_f == -1.0 && PyErr_Occurred()) {
throwCAPIException();
......@@ -628,24 +628,24 @@ extern "C" Box* floatMod(BoxedFloat* lhs, Box* rhs) {
}
extern "C" Box* floatRModFloat(BoxedFloat* lhs, BoxedFloat* rhs) {
assert(lhs->cls == float_cls);
assert(rhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyFloat_Check(rhs));
return boxFloat(mod_float_float(rhs->d, lhs->d));
}
extern "C" Box* floatRModInt(BoxedFloat* lhs, BoxedInt* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyInt_Check(rhs));
return boxFloat(mod_float_float(rhs->n, lhs->d));
}
extern "C" Box* floatRMod(BoxedFloat* lhs, Box* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
if (PyInt_Check(rhs)) {
return floatRModInt(lhs, static_cast<BoxedInt*>(rhs));
} else if (rhs->cls == float_cls) {
} else if (PyFloat_Check(rhs)) {
return floatRModFloat(lhs, static_cast<BoxedFloat*>(rhs));
} else if (rhs->cls == long_cls) {
} else if (PyLong_Check(rhs)) {
double rhs_f = PyLong_AsDouble(rhs);
if (rhs_f == -1.0 && PyErr_Occurred()) {
throwCAPIException();
......@@ -690,14 +690,14 @@ extern "C" Box* floatPow(BoxedFloat* lhs, Box* rhs, Box* mod) {
extern "C" Box* floatPowFloat(BoxedFloat* lhs, BoxedFloat* rhs, Box* mod = None) {
// TODO to specialize this, need to account for all the special cases in float_pow
assert(lhs->cls == float_cls);
assert(rhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyFloat_Check(rhs));
return floatPow(lhs, rhs, mod);
}
extern "C" Box* floatPowInt(BoxedFloat* lhs, BoxedInt* rhs, Box* mod = None) {
// TODO to specialize this, need to account for all the special cases in float_pow
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyInt_Check(rhs));
return floatPow(lhs, rhs, mod);
}
......@@ -725,24 +725,24 @@ extern "C" double pow_float_float(double lhs, double rhs) {
}
extern "C" Box* floatMulFloat(BoxedFloat* lhs, BoxedFloat* rhs) {
assert(lhs->cls == float_cls);
assert(rhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyFloat_Check(rhs));
return boxFloat(lhs->d * rhs->d);
}
extern "C" Box* floatMulInt(BoxedFloat* lhs, BoxedInt* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyInt_Check(rhs));
return boxFloat(lhs->d * rhs->n);
}
extern "C" Box* floatMul(BoxedFloat* lhs, Box* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
if (PyInt_Check(rhs)) {
return floatMulInt(lhs, static_cast<BoxedInt*>(rhs));
} else if (rhs->cls == float_cls) {
} else if (PyFloat_Check(rhs)) {
return floatMulFloat(lhs, static_cast<BoxedFloat*>(rhs));
} else if (rhs->cls == long_cls) {
} else if (PyLong_Check(rhs)) {
double rhs_f = PyLong_AsDouble(rhs);
if (rhs_f == -1.0 && PyErr_Occurred()) {
throwCAPIException();
......@@ -754,24 +754,24 @@ extern "C" Box* floatMul(BoxedFloat* lhs, Box* rhs) {
}
extern "C" Box* floatSubFloat(BoxedFloat* lhs, BoxedFloat* rhs) {
assert(lhs->cls == float_cls);
assert(rhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyFloat_Check(rhs));
return boxFloat(lhs->d - rhs->d);
}
extern "C" Box* floatSubInt(BoxedFloat* lhs, BoxedInt* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyInt_Check(rhs));
return boxFloat(lhs->d - rhs->n);
}
extern "C" Box* floatSub(BoxedFloat* lhs, Box* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
if (PyInt_Check(rhs)) {
return floatSubInt(lhs, static_cast<BoxedInt*>(rhs));
} else if (rhs->cls == float_cls) {
} else if (PyFloat_Check(rhs)) {
return floatSubFloat(lhs, static_cast<BoxedFloat*>(rhs));
} else if (rhs->cls == long_cls) {
} else if (PyLong_Check(rhs)) {
double rhs_f = PyLong_AsDouble(rhs);
if (rhs_f == -1.0 && PyErr_Occurred()) {
throwCAPIException();
......@@ -783,24 +783,24 @@ extern "C" Box* floatSub(BoxedFloat* lhs, Box* rhs) {
}
extern "C" Box* floatRSubFloat(BoxedFloat* lhs, BoxedFloat* rhs) {
assert(lhs->cls == float_cls);
assert(rhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyFloat_Check(rhs));
return boxFloat(rhs->d - lhs->d);
}
extern "C" Box* floatRSubInt(BoxedFloat* lhs, BoxedInt* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
assert(PyInt_Check(rhs));
return boxFloat(rhs->n - lhs->d);
}
extern "C" Box* floatRSub(BoxedFloat* lhs, Box* rhs) {
assert(lhs->cls == float_cls);
assert(PyFloat_Check(lhs));
if (PyInt_Check(rhs)) {
return floatRSubInt(lhs, static_cast<BoxedInt*>(rhs));
} else if (rhs->cls == float_cls) {
} else if (PyFloat_Check(rhs)) {
return floatRSubFloat(lhs, static_cast<BoxedFloat*>(rhs));
} else if (rhs->cls == long_cls) {
} else if (PyLong_Check(rhs)) {
double rhs_f = PyLong_AsDouble(rhs);
if (rhs_f == -1.0 && PyErr_Occurred()) {
throwCAPIException();
......@@ -812,12 +812,12 @@ extern "C" Box* floatRSub(BoxedFloat* lhs, Box* rhs) {
}
Box* floatNeg(BoxedFloat* self) {
assert(self->cls == float_cls);
assert(PyFloat_Check(self));
return boxFloat(-self->d);
}
Box* floatPos(BoxedFloat* self) {
assert(self->cls == float_cls);
assert(PyFloat_Check(self));
return PyFloat_FromDouble(self->d);
}
......@@ -830,7 +830,7 @@ Box* floatAbs(BoxedFloat* self) {
}
bool floatNonzeroUnboxed(BoxedFloat* self) {
assert(self->cls == float_cls);
assert(PyFloat_Check(self));
return self->d != 0.0;
}
......@@ -1115,18 +1115,18 @@ extern "C" void printFloat(double d) {
static void _addFunc(const char* name, ConcreteCompilerType* rtn_type, void* float_func, void* int_func,
void* boxed_func) {
std::vector<ConcreteCompilerType*> v_ff, v_fi, v_fu;
std::vector<ConcreteCompilerType*> v_ff, v_fi, v_uu;
v_ff.push_back(BOXED_FLOAT);
v_ff.push_back(BOXED_FLOAT);
v_fi.push_back(BOXED_FLOAT);
v_fi.push_back(BOXED_INT);
v_fu.push_back(BOXED_FLOAT);
v_fu.push_back(UNKNOWN);
v_uu.push_back(UNKNOWN);
v_uu.push_back(UNKNOWN);
FunctionMetadata* md = new FunctionMetadata(2, false, false);
md->addVersion(float_func, rtn_type, v_ff);
md->addVersion(int_func, rtn_type, v_fi);
md->addVersion(boxed_func, UNKNOWN, v_fu);
md->addVersion(boxed_func, UNKNOWN, v_uu);
float_cls->giveAttr(name, new BoxedFunction(md));
}
......
src/runtime/int.cpp
View file @ 19db347a
......@@ -483,7 +483,7 @@ extern "C" Box* intAddInt(BoxedInt* lhs, BoxedInt* rhs) {
extern "C" Box* intAddFloat(BoxedInt* lhs, BoxedFloat* rhs) {
assert(PyInt_Check(lhs));
assert(rhs->cls == float_cls);
assert(PyFloat_Check(rhs));
return boxFloat(lhs->n + rhs->d);
}
......@@ -494,7 +494,7 @@ extern "C" Box* intAdd(BoxedInt* lhs, Box* rhs) {
if (PyInt_Check(rhs)) {
BoxedInt* rhs_int = static_cast<BoxedInt*>(rhs);
return add_i64_i64(lhs->n, rhs_int->n);
} else if (rhs->cls == float_cls) {
} else if (PyFloat_Check(rhs)) {
BoxedFloat* rhs_float = static_cast<BoxedFloat*>(rhs);
return boxFloat(lhs->n + rhs_float->d);
} else {
......@@ -609,7 +609,7 @@ extern "C" Box* intDivInt(BoxedInt* lhs, BoxedInt* rhs) {
extern "C" Box* intDivFloat(BoxedInt* lhs, BoxedFloat* rhs) {
assert(PyInt_Check(lhs));
assert(rhs->cls == float_cls);
assert(PyFloat_Check(rhs));
if (rhs->d == 0) {
raiseExcHelper(ZeroDivisionError, "float divide by zero");
......@@ -623,7 +623,7 @@ extern "C" Box* intDiv(BoxedInt* lhs, Box* rhs) {
if (PyInt_Check(rhs)) {
return intDivInt(lhs, static_cast<BoxedInt*>(rhs));
} else if (rhs->cls == float_cls) {
} else if (PyFloat_Check(rhs)) {
return intDivFloat(lhs, static_cast<BoxedFloat*>(rhs));
} else {
return incref(NotImplemented);
......@@ -650,7 +650,7 @@ extern "C" Box* intFloordivInt(BoxedInt* lhs, BoxedInt* rhs) {
extern "C" Box* intFloordivFloat(BoxedInt* lhs, BoxedFloat* rhs) {
assert(PyInt_Check(lhs));
assert(rhs->cls == float_cls);
assert(PyFloat_Check(rhs));
if (rhs->d == 0) {
raiseExcHelper(ZeroDivisionError, "float divide by zero");
......@@ -665,7 +665,7 @@ extern "C" Box* intFloordiv(BoxedInt* lhs, Box* rhs) {
if (PyInt_Check(rhs)) {
return intFloordivInt(lhs, static_cast<BoxedInt*>(rhs));
} else if (rhs->cls == float_cls) {
} else if (PyFloat_Check(rhs)) {
return intFloordivFloat(lhs, static_cast<BoxedFloat*>(rhs));
} else {
return incref(NotImplemented);
......@@ -696,7 +696,7 @@ extern "C" Box* intTruedivInt(BoxedInt* lhs, BoxedInt* rhs) {
extern "C" Box* intTruedivFloat(BoxedInt* lhs, BoxedFloat* rhs) {
assert(PyInt_Check(lhs));
assert(rhs->cls == float_cls);
assert(PyFloat_Check(rhs));
if (rhs->d == 0) {
raiseExcHelper(ZeroDivisionError, "division by zero");
......@@ -711,7 +711,7 @@ extern "C" Box* intTruediv(BoxedInt* lhs, Box* rhs) {
if (PyInt_Check(rhs)) {
return intTruedivInt(lhs, static_cast<BoxedInt*>(rhs));
} else if (rhs->cls == float_cls) {
} else if (PyFloat_Check(rhs)) {
return intTruedivFloat(lhs, static_cast<BoxedFloat*>(rhs));
} else {
return incref(NotImplemented);
......@@ -751,7 +751,7 @@ extern "C" Box* intLShift(BoxedInt* lhs, Box* rhs) {
raiseExcHelper(TypeError, "descriptor '__lshift__' requires a 'int' object but received a '%s'",
getTypeName(lhs));
if (rhs->cls == long_cls)
if (PyLong_Check(rhs))
return longLShiftLong(autoDecref(boxLong(lhs->n)), rhs);
if (!PyInt_Check(rhs)) {
......@@ -847,7 +847,7 @@ extern "C" Box* intMulInt(BoxedInt* lhs, BoxedInt* rhs) {
extern "C" Box* intMulFloat(BoxedInt* lhs, BoxedFloat* rhs) {
assert(PyInt_Check(lhs));
assert(rhs->cls == float_cls);
assert(PyFloat_Check(rhs));
return boxFloat(lhs->n * rhs->d);
}
......@@ -858,7 +858,7 @@ extern "C" Box* intMul(BoxedInt* lhs, Box* rhs) {
if (PyInt_Check(rhs)) {
BoxedInt* rhs_int = static_cast<BoxedInt*>(rhs);
return intMulInt(lhs, rhs_int);
} else if (rhs->cls == float_cls) {
} else if (PyFloat_Check(rhs)) {
BoxedFloat* rhs_float = static_cast<BoxedFloat*>(rhs);
return intMulFloat(lhs, rhs_float);
} else {
......@@ -896,7 +896,7 @@ extern "C" Box* intPowLong(BoxedInt* lhs, BoxedLong* rhs, Box* mod) {
extern "C" Box* intPowFloat(BoxedInt* lhs, BoxedFloat* rhs, Box* mod) {
assert(PyInt_Check(lhs));
assert(rhs->cls == float_cls);
assert(PyFloat_Check(rhs));
if (mod != None) {
raiseExcHelper(TypeError, "pow() 3rd argument not allowed unless all arguments are integers");
......@@ -964,7 +964,7 @@ extern "C" Box* intRShift(BoxedInt* lhs, Box* rhs) {
raiseExcHelper(TypeError, "descriptor '__rshift__' requires a 'int' object but received a '%s'",
getTypeName(lhs));
if (rhs->cls == long_cls)
if (PyLong_Check(rhs))
return longRShiftLong(autoDecref(boxLong(lhs->n)), rhs);
if (!PyInt_Check(rhs)) {
......@@ -994,7 +994,7 @@ extern "C" Box* intSubInt(BoxedInt* lhs, BoxedInt* rhs) {
extern "C" Box* intSubFloat(BoxedInt* lhs, BoxedFloat* rhs) {
assert(PyInt_Check(lhs));
assert(rhs->cls == float_cls);
assert(PyFloat_Check(rhs));
return boxFloat(lhs->n - rhs->d);
}
......@@ -1005,7 +1005,7 @@ extern "C" Box* intSub(BoxedInt* lhs, Box* rhs) {
if (PyInt_Check(rhs)) {
BoxedInt* rhs_int = static_cast<BoxedInt*>(rhs);
return intSubInt(lhs, rhs_int);
} else if (rhs->cls == float_cls) {
} else if (PyFloat_Check(rhs)) {
BoxedFloat* rhs_float = static_cast<BoxedFloat*>(rhs);
return intSubFloat(lhs, rhs_float);
} else {
......
test/integration/numpy_patch.patch
View file @ 19db347a
diff --git a/numpy/__init__.py b/numpy/__init__.py
index d4ef54d..7a49dbd 100644
--- a/numpy/__init__.py
+++ b/numpy/__init__.py
@@ -196,7 +196,7 @@ else:
from . import linalg
from . import fft
from . import polynomial
- from . import random
+ # from . import random
from . import ctypeslib
from . import ma
from . import matrixlib as _mat
@@ -218,7 +218,8 @@ else:
__all__.extend(core.__all__)
__all__.extend(_mat.__all__)
__all__.extend(lib.__all__)
- __all__.extend(['linalg', 'fft', 'random', 'ctypeslib', 'ma'])
+ __all__.extend(['linalg', 'fft', 'ctypeslib', 'ma'])
+ # __all__.extend(['linalg', 'fft', 'random', 'ctypeslib', 'ma'])
# Filter annoying Cython warnings that serve no good purpose.
import warnings
diff --git a/numpy/core/include/numpy/ndarrayobject.h b/numpy/core/include/numpy/ndarrayobject.h
index fbaaeac..cb4adbb 100644
--- a/numpy/core/include/numpy/ndarrayobject.h
......@@ -193,20 +170,6 @@ index 7797731..93edc66 100644
return NULL;
}
diff --git a/numpy/core/tests/test_function_base.py b/numpy/core/tests/test_function_base.py
index 2df7ba3..88fac0a 100644
--- a/numpy/core/tests/test_function_base.py
+++ b/numpy/core/tests/test_function_base.py
@@ -113,7 +113,8 @@ class TestLinspace(TestCase):
a = PhysicalQuantity(0.0)
b = PhysicalQuantity(1.0)
- assert_equal(linspace(a, b), linspace(0.0, 1.0))
+ # TODO: Need to support operations on inherited floats like divide.
+ # assert_equal(linspace(a, b), linspace(0.0, 1.0))
def test_denormal_numbers(self):
# Regression test for gh-5437. Will probably fail when compiled
diff --git a/numpy/core/tests/test_records.py b/numpy/core/tests/test_records.py
index 7a18f29..a8d4e4b 100644
--- a/numpy/core/tests/test_records.py
......@@ -282,40 +245,3 @@ index dba74d3..23cfeed 100644
def test_masked_array_repeat(self, level=rlevel):
# Ticket #271
diff --git a/numpy/random/setup.py b/numpy/random/setup.py
index 9d90590..b3ee24f 100644
--- a/numpy/random/setup.py
+++ b/numpy/random/setup.py
@@ -39,18 +39,6 @@ def configuration(parent_package='',top_path=None):
libs = []
# Configure mtrand
- config.add_extension('mtrand',
- sources=[join('mtrand', x) for x in
- ['mtrand.c', 'randomkit.c', 'initarray.c',
- 'distributions.c']]+[generate_libraries],
- libraries=libs,
- depends=[join('mtrand', '*.h'),
- join('mtrand', '*.pyx'),
- join('mtrand', '*.pxi'),],
- define_macros=defs,
- )
-
- config.add_data_files(('.', join('mtrand', 'randomkit.h')))
config.add_data_dir('tests')
return config
diff --git a/setup.py b/setup.py
index 90dcb24..943851a 100755
--- a/setup.py
+++ b/setup.py
@@ -245,7 +245,8 @@ def setup_package():
cwd = os.path.abspath(os.path.dirname(__file__))
if not os.path.exists(os.path.join(cwd, 'PKG-INFO')):
# Generate Cython sources, unless building from source release
- generate_cython()
+ # generate_cython()
+ pass
metadata['configuration'] = configuration
try:
test/tests/future_division.py
View file @ 19db347a
......@@ -22,3 +22,19 @@ test(-3.0, -2.0)
test(1.0 + 1.0j, 2)
test(1.0 + 1.0j, 2.0)
test(1.0 + 1.0j, 2.0j)
class PhysicalQuantity(float):
def __new__(cls, value):
return float.__new__(cls, value)
def __div__(self, x):
print('__div__ get called')
return PhysicalQuantity(float(self) / float(x))
def __rdiv__(self, x):
print('__rdiv__ get called')
return PhysicalQuantity(float(x) / float(self))
a = PhysicalQuantity(2.0)
print(a / 3.0)
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7