from pypy.interpreter.error import OperationError, oefmt from pypy.interpreter.gateway import interp2app, unwrap_spec from pypy.interpreter.mixedmodule import MixedModule from pypy.interpreter.typedef import TypeDef, GetSetProperty from pypy.objspace.std.bytesobject import W_BytesObject from pypy.objspace.std.complexobject import W_ComplexObject from pypy.objspace.std.floatobject import W_FloatObject from pypy.objspace.std.intobject import W_IntObject from pypy.objspace.std.unicodeobject import W_UnicodeObject from rpython.rlib.rarithmetic import LONG_BIT from rpython.rlib.rstring import StringBuilder from rpython.rlib.objectmodel import specialize from rpython.rlib import jit from rpython.rlib.rutf8 import codepoints_in_utf8 from rpython.rtyper.lltypesystem import lltype, rffi from rpython.tool.sourcetools import func_with_new_name from pypy.module.micronumpy import constants as NPY from pypy.module.micronumpy.base import W_NDimArray, W_NumpyObject from pypy.module.micronumpy.concrete import VoidBoxStorage from pypy.module.micronumpy.flagsobj import W_FlagsObject from pypy.module.micronumpy import support MIXIN_32 = (W_IntObject.typedef,) if LONG_BIT == 32 else () MIXIN_64 = (W_IntObject.typedef,) if LONG_BIT == 64 else () #long_double_size = rffi.sizeof_c_type('long double', ignore_errors=True) #import os #if long_double_size == 8 and os.name == 'nt': # # this is a lie, or maybe a wish, MS fakes longdouble math with double # long_double_size = 12 # hardcode to 8 for now (simulate using normal double) until long double works long_double_size = 8 def new_dtype_getter(num): @specialize.memo() def _get_dtype(space): from pypy.module.micronumpy.descriptor import num2dtype return num2dtype(space, num) def descr__new__(space, w_subtype, w_value=None): from pypy.module.micronumpy.ctors import array dtype = _get_dtype(space) if not space.is_none(w_value): w_arr = array(space, w_value, dtype, copy=False) if len(w_arr.get_shape()) != 0: return w_arr w_value = w_arr.get_scalar_value().item(space) return dtype.itemtype.coerce_subtype(space, w_subtype, w_value) def descr_reduce(self, space): return self.reduce(space) return (func_with_new_name(descr__new__, 'descr__new__%d' % num), staticmethod(_get_dtype), descr_reduce) class Box(object): _mixin_ = True def reduce(self, space): _numpypy = space.getbuiltinmodule("_numpypy") assert isinstance(_numpypy, MixedModule) multiarray = _numpypy.get("multiarray") assert isinstance(multiarray, MixedModule) scalar = multiarray.get("scalar") ret = space.newtuple([scalar, space.newtuple( [self._get_dtype(space), space.newtext(self.raw_str())])]) return ret class PrimitiveBox(Box): _mixin_ = True _immutable_fields_ = ['value'] def __init__(self, value): self.value = value def convert_to(self, space, dtype): return dtype.box(self.value) def __repr__(self): return '%s(%s)' % (self.__class__.__name__, self.value) def raw_str(self): value = lltype.malloc(rffi.CArray(lltype.typeOf(self.value)), 1, flavor="raw") value[0] = self.value builder = StringBuilder() builder.append_charpsize(rffi.cast(rffi.CCHARP, value), rffi.sizeof(lltype.typeOf(self.value))) ret = builder.build() lltype.free(value, flavor="raw") return ret class ComplexBox(Box): _mixin_ = True _immutable_fields_ = ['real', 'imag'] def __init__(self, real, imag=0.): self.real = real self.imag = imag def convert_to(self, space, dtype): return dtype.box_complex(self.real, self.imag) def convert_real_to(self, dtype): return dtype.box(self.real) def convert_imag_to(self, dtype): return dtype.box(self.imag) def raw_str(self): value = lltype.malloc(rffi.CArray(lltype.typeOf(self.real)), 2, flavor="raw") value[0] = self.real value[1] = self.imag builder = StringBuilder() builder.append_charpsize(rffi.cast(rffi.CCHARP, value), rffi.sizeof(lltype.typeOf(self.real)) * 2) ret = builder.build() lltype.free(value, flavor="raw") return ret class W_GenericBox(W_NumpyObject): _attrs_ = ['w_flags'] def descr__new__(space, w_subtype, __args__): raise oefmt(space.w_TypeError, "cannot create '%N' instances", w_subtype) def get_dtype(self, space): return self._get_dtype(space) def is_scalar(self): return True def get_scalar_value(self): return self def get_flags(self): return (NPY.ARRAY_C_CONTIGUOUS | NPY.ARRAY_F_CONTIGUOUS | NPY.ARRAY_ALIGNED | NPY.ARRAY_OWNDATA) def item(self, space): return self.get_dtype(space).itemtype.to_builtin_type(space, self) def descr_item(self, space, args_w): if len(args_w) == 1 and space.isinstance_w(args_w[0], space.w_tuple): args_w = space.fixedview(args_w[0]) if len(args_w) > 1: raise oefmt(space.w_ValueError, "incorrect number of indices for array") elif len(args_w) == 1: try: idx = support.index_w(space, args_w[0]) except OperationError: raise oefmt(space.w_TypeError, "an integer is required") if idx != 0: raise oefmt(space.w_IndexError, "index %d is out of bounds for size 1", idx) return self.item(space) def descr_transpose(self, space, args_w): if len(args_w) == 1 and space.isinstance_w(args_w[0], space.w_tuple): args_w = space.fixedview(args_w[0]) if len(args_w) >= 1: for w_arg in args_w: try: support.index_w(space, w_arg) except OperationError: raise oefmt(space.w_TypeError, "an integer is required") raise oefmt(space.w_ValueError, "axes don't match array") return self def descr_getitem(self, space, w_item): from pypy.module.micronumpy.base import convert_to_array if space.is_w(w_item, space.w_Ellipsis): return convert_to_array(space, self) elif (space.isinstance_w(w_item, space.w_tuple) and space.len_w(w_item) == 0): return self raise oefmt(space.w_IndexError, "invalid index to scalar variable") def descr_iter(self, space): # Making numpy scalar non-iterable with a valid __getitem__ method raise oefmt(space.w_TypeError, "'%T' object is not iterable", self) def descr_str(self, space): tp = self.get_dtype(space).itemtype return space.newtext(tp.str_format(self, add_quotes=False)) def descr_repr(self, space): tp = self.get_dtype(space).itemtype return space.newtext(tp.str_format(self, add_quotes=True)) def descr_format(self, space, w_spec): return space.format(self.item(space), w_spec) def descr_hash(self, space): return space.hash(self.item(space)) def descr___array_priority__(self, space): return space.newfloat(0.0) def descr_index(self, space): return space.index(self.item(space)) def descr_int(self, space): if isinstance(self, W_ComplexFloatingBox): box = self.descr_get_real(space) else: box = self return space.call_function(space.w_int, box.item(space)) def descr_float(self, space): if isinstance(self, W_ComplexFloatingBox): box = self.descr_get_real(space) else: box = self return space.call_function(space.w_float, box.item(space)) def descr_oct(self, space): return space.call_method(space.builtin, 'oct', self.descr_int(space)) def descr_hex(self, space): return space.call_method(space.builtin, 'hex', self.descr_int(space)) def descr_nonzero(self, space): return space.newbool(self.get_dtype(space).itemtype.bool(self)) # TODO: support all kwargs in ufuncs like numpy ufunc_object.c sig = None cast = 'unsafe' extobj = None def _unaryop_impl(ufunc_name): def impl(self, space, w_out=None): from pypy.module.micronumpy import ufuncs return getattr(ufuncs.get(space), ufunc_name).call( space, [self, w_out], self.sig, self.cast, self.extobj) return func_with_new_name(impl, "unaryop_%s_impl" % ufunc_name) def _binop_impl(ufunc_name): def impl(self, space, w_other, w_out=None): from pypy.module.micronumpy import ufuncs return getattr(ufuncs.get(space), ufunc_name).call( space, [self, w_other, w_out], self.sig, self.cast, self.extobj) return func_with_new_name(impl, "binop_%s_impl" % ufunc_name) def _binop_right_impl(ufunc_name): def impl(self, space, w_other, w_out=None): from pypy.module.micronumpy import ufuncs return getattr(ufuncs.get(space), ufunc_name).call( space, [w_other, self, w_out], self.sig, self.cast, self.extobj) return func_with_new_name(impl, "binop_right_%s_impl" % ufunc_name) descr_add = _binop_impl("add") descr_sub = _binop_impl("subtract") descr_mul = _binop_impl("multiply") descr_div = _binop_impl("divide") descr_truediv = _binop_impl("true_divide") descr_floordiv = _binop_impl("floor_divide") descr_mod = _binop_impl("mod") descr_pow = _binop_impl("power") descr_lshift = _binop_impl("left_shift") descr_rshift = _binop_impl("right_shift") descr_and = _binop_impl("bitwise_and") descr_or = _binop_impl("bitwise_or") descr_xor = _binop_impl("bitwise_xor") descr_eq = _binop_impl("equal") descr_ne = _binop_impl("not_equal") descr_lt = _binop_impl("less") descr_le = _binop_impl("less_equal") descr_gt = _binop_impl("greater") descr_ge = _binop_impl("greater_equal") descr_radd = _binop_right_impl("add") descr_rsub = _binop_right_impl("subtract") descr_rmul = _binop_right_impl("multiply") descr_rdiv = _binop_right_impl("divide") descr_rtruediv = _binop_right_impl("true_divide") descr_rfloordiv = _binop_right_impl("floor_divide") descr_rmod = _binop_right_impl("mod") descr_rpow = _binop_right_impl("power") descr_rlshift = _binop_right_impl("left_shift") descr_rrshift = _binop_right_impl("right_shift") descr_rand = _binop_right_impl("bitwise_and") descr_ror = _binop_right_impl("bitwise_or") descr_rxor = _binop_right_impl("bitwise_xor") descr_pos = _unaryop_impl("positive") descr_neg = _unaryop_impl("negative") descr_abs = _unaryop_impl("absolute") descr_invert = _unaryop_impl("invert") descr_conjugate = _unaryop_impl("conjugate") def descr_divmod(self, space, w_other): w_quotient = self.descr_div(space, w_other) w_remainder = self.descr_mod(space, w_other) return space.newtuple([w_quotient, w_remainder]) def descr_rdivmod(self, space, w_other): w_quotient = self.descr_rdiv(space, w_other) w_remainder = self.descr_rmod(space, w_other) return space.newtuple([w_quotient, w_remainder]) def descr_any(self, space): from pypy.module.micronumpy.descriptor import get_dtype_cache value = space.is_true(self) return get_dtype_cache(space).w_booldtype.box(value) def descr_all(self, space): from pypy.module.micronumpy.descriptor import get_dtype_cache value = space.is_true(self) return get_dtype_cache(space).w_booldtype.box(value) def descr_zero(self, space): from pypy.module.micronumpy.descriptor import get_dtype_cache return get_dtype_cache(space).w_longdtype.box(0) def descr_ravel(self, space): from pypy.module.micronumpy.base import convert_to_array w_values = space.newtuple([self]) return convert_to_array(space, w_values) @unwrap_spec(decimals=int) def descr_round(self, space, decimals=0, w_out=None): if not space.is_none(w_out): raise oefmt(space.w_NotImplementedError, "out not supported") return self.get_dtype(space).itemtype.round(self, decimals) def descr_astype(self, space, w_dtype): from pypy.module.micronumpy.descriptor import W_Dtype dtype = space.interp_w(W_Dtype, space.call_function(space.gettypefor(W_Dtype), w_dtype)) return self.convert_to(space, dtype) def descr_view(self, space, w_dtype): from pypy.module.micronumpy.descriptor import W_Dtype try: subclass = space.issubtype_w(w_dtype, space.gettypefor(W_NDimArray)) except OperationError as e: if e.match(space, space.w_TypeError): subclass = False else: raise if subclass: dtype = self.get_dtype(space) else: dtype = space.interp_w(W_Dtype, space.call_function(space.gettypefor(W_Dtype), w_dtype)) if dtype.elsize == 0: raise oefmt(space.w_TypeError, "data-type must not be 0-sized") if dtype.elsize != self.get_dtype(space).elsize: raise oefmt(space.w_ValueError, "new type not compatible with array.") if dtype.is_record(): raise oefmt(space.w_NotImplementedError, "viewing scalar as record not implemented") else: return dtype.runpack_str(space, self.raw_str()) def descr_self(self, space): return self def descr_get_dtype(self, space): return self.get_dtype(space) def descr_get_size(self, space): return space.newint(1) def descr_get_itemsize(self, space): return space.newint(self.get_dtype(space).elsize) def descr_get_shape(self, space): return space.newtuple([]) def descr_get_ndim(self, space): return space.newint(0) def descr_copy(self, space): return self.convert_to(space, self.get_dtype(space)) def buffer_w(self, space, flags): return self.descr_ravel(space).buffer_w(space, flags) def descr_byteswap(self, space): return self.get_dtype(space).itemtype.byteswap(self) def descr_tostring(self, space, __args__): w_meth = space.getattr(self.descr_ravel(space), space.newtext('tostring')) return space.call_args(w_meth, __args__) def descr_reshape(self, space, __args__): w_meth = space.getattr(self.descr_ravel(space), space.newtext('reshape')) w_res = space.call_args(w_meth, __args__) if isinstance(w_res, W_NDimArray) and len(w_res.get_shape()) == 0: return w_res.get_scalar_value() return w_res def descr_nd_nonzero(self, space, __args__): w_meth = space.getattr(self.descr_ravel(space), space.newtext('nonzero')) return space.call_args(w_meth, __args__) def descr_get_real(self, space): return self.get_dtype(space).itemtype.real(self) def descr_get_imag(self, space): return self.get_dtype(space).itemtype.imag(self) w_flags = None def descr_get_flags(self, space): if self.w_flags is None: self.w_flags = W_FlagsObject(self) return self.w_flags @unwrap_spec(axis1=int, axis2=int) def descr_swapaxes(self, space, axis1, axis2): raise oefmt(space.w_ValueError, 'bad axis1 argument to swapaxes') def descr_fill(self, space, w_value): self.get_dtype(space).coerce(space, w_value) class W_BoolBox(W_GenericBox, PrimitiveBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.BOOL) class W_NumberBox(W_GenericBox): pass class W_IntegerBox(W_NumberBox): def _int_w(self, space): return space.int_w(self.descr_int(space)) class W_SignedIntegerBox(W_IntegerBox): pass class W_UnsignedIntegerBox(W_IntegerBox): pass class W_Int8Box(W_SignedIntegerBox, PrimitiveBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.BYTE) class W_UInt8Box(W_UnsignedIntegerBox, PrimitiveBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.UBYTE) class W_Int16Box(W_SignedIntegerBox, PrimitiveBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.SHORT) class W_UInt16Box(W_UnsignedIntegerBox, PrimitiveBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.USHORT) class W_Int32Box(W_SignedIntegerBox, PrimitiveBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.INT) class W_UInt32Box(W_UnsignedIntegerBox, PrimitiveBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.UINT) class W_LongBox(W_SignedIntegerBox, PrimitiveBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.LONG) class W_ULongBox(W_UnsignedIntegerBox, PrimitiveBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.ULONG) class W_Int64Box(W_SignedIntegerBox, PrimitiveBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.LONGLONG) class W_UInt64Box(W_UnsignedIntegerBox, PrimitiveBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.ULONGLONG) class W_InexactBox(W_NumberBox): pass class W_FloatingBox(W_InexactBox): pass class W_Float16Box(W_FloatingBox, PrimitiveBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.HALF) class W_Float32Box(W_FloatingBox, PrimitiveBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.FLOAT) class W_Float64Box(W_FloatingBox, PrimitiveBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.DOUBLE) def descr_as_integer_ratio(self, space): return space.call_method(self.item(space), 'as_integer_ratio') class W_ComplexFloatingBox(W_InexactBox): pass class W_Complex64Box(ComplexBox, W_ComplexFloatingBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.CFLOAT) class W_Complex128Box(ComplexBox, W_ComplexFloatingBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.CDOUBLE) if long_double_size in (8, 12, 16): class W_FloatLongBox(W_FloatingBox, PrimitiveBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.LONGDOUBLE) class W_ComplexLongBox(ComplexBox, W_ComplexFloatingBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.CLONGDOUBLE) class W_FlexibleBox(W_GenericBox): _attrs_ = ['arr', 'ofs', 'dtype'] _immutable_fields_ = ['arr', 'ofs', 'dtype'] def __init__(self, arr, ofs, dtype): self.arr = arr # we have to keep array alive self.ofs = ofs self.dtype = dtype def get_dtype(self, space): return self.dtype @jit.unroll_safe def raw_str(self): builder = StringBuilder() i = self.ofs end = i + self.dtype.elsize with self.arr as storage: while i < end: assert isinstance(storage[i], str) if storage[i] == '\x00': break builder.append(storage[i]) i += 1 return builder.build() class W_VoidBox(W_FlexibleBox): def descr_getitem(self, space, w_item): if space.isinstance_w(w_item, space.w_text): item = space.text_w(w_item) elif space.isinstance_w(w_item, space.w_bytes): item = space.bytes_w(w_item) # XXX should it be supported? elif space.isinstance_w(w_item, space.w_int): indx = space.int_w(w_item) try: item = self.dtype.names[indx][0] except IndexError: if indx < 0: indx += len(self.dtype.names) raise oefmt(space.w_IndexError, "invalid index (%d)", indx) else: raise oefmt(space.w_IndexError, "invalid index") try: ofs, dtype = self.dtype.fields[item] except KeyError: raise oefmt(space.w_ValueError, "no field of name %s", item) from pypy.module.micronumpy.types import VoidType if isinstance(dtype.itemtype, VoidType): read_val = dtype.itemtype.readarray(self.arr, self.ofs, ofs, dtype) else: read_val = dtype.read(self.arr, self.ofs, ofs) if isinstance (read_val, W_StringBox): # StringType returns a str return space.newbytes(dtype.itemtype.to_str(read_val)) return read_val def descr_iter(self, space): return space.newseqiter(self) def descr_setitem(self, space, w_item, w_value): if space.isinstance_w(w_item, space.w_text): item = space.text_w(w_item) elif space.isinstance_w(w_item, space.w_bytes): item = space.bytes_w(w_item) # XXX should it be supported? elif space.isinstance_w(w_item, space.w_int): indx = space.int_w(w_item) try: item = self.dtype.names[indx][0] except IndexError: if indx < 0: indx += len(self.dtype.names) raise oefmt(space.w_IndexError, "invalid index (%d)", indx) else: raise oefmt(space.w_IndexError, "invalid index") try: ofs, dtype = self.dtype.fields[item] except KeyError: raise oefmt(space.w_IndexError, "only integers, slices (`:`), " "ellipsis (`...`), numpy.newaxis (`None`) and integer or " "boolean arrays are valid indices") dtype.store(self.arr, self.ofs, ofs, dtype.coerce(space, w_value)) def convert_to(self, space, dtype): # if we reach here, the record fields are guarenteed to match. return self class W_CharacterBox(W_FlexibleBox): def convert_to(self, space, dtype): # XXX should be newbytes? return dtype.coerce(space, space.newtext(self.raw_str())) def descr_len(self, space): return space.len(self.item(space)) class W_StringBox(W_CharacterBox): def descr__new__string_box(space, w_subtype, w_arg): from pypy.module.micronumpy.descriptor import new_string_dtype arg = space.text_w(space.str(w_arg)) arr = VoidBoxStorage(len(arg), new_string_dtype(space, len(arg))) for i in range(len(arg)): arr.storage[i] = arg[i] return W_StringBox(arr, 0, arr.dtype) class W_UnicodeBox(W_CharacterBox): def __init__(self, value): self._value = value def convert_to(self, space, dtype): if dtype.is_unicode(): return self elif dtype.is_object(): return W_ObjectBox(space.newutf8(self._value, codepoints_in_utf8(self._value))) else: raise oefmt(space.w_NotImplementedError, "Conversion from unicode not implemented yet") def get_dtype(self, space): from pypy.module.micronumpy.descriptor import new_unicode_dtype return new_unicode_dtype(space, len(self._value)) def descr__new__unicode_box(space, w_subtype, w_arg): value = space.utf8_w(space.unicode_from_object(w_arg)) return W_UnicodeBox(value) class W_ObjectBox(W_GenericBox): descr__new__, _get_dtype, descr_reduce = new_dtype_getter(NPY.OBJECT) def __init__(self, w_obj): self.w_obj = w_obj def convert_to(self, space, dtype): if dtype.is_bool(): return W_BoolBox(space.bool_w(self.w_obj)) return self # XXX def descr__getattr__(self, space, w_key): return space.getattr(self.w_obj, w_key) W_GenericBox.typedef = TypeDef("numpy.generic", None, None, "read-write", __new__ = interp2app(W_GenericBox.descr__new__.im_func), __getitem__ = interp2app(W_GenericBox.descr_getitem), __iter__ = interp2app(W_GenericBox.descr_iter), __str__ = interp2app(W_GenericBox.descr_str), __repr__ = interp2app(W_GenericBox.descr_repr), __format__ = interp2app(W_GenericBox.descr_format), __int__ = interp2app(W_GenericBox.descr_int), __float__ = interp2app(W_GenericBox.descr_float), __bool__ = interp2app(W_GenericBox.descr_nonzero), __oct__ = interp2app(W_GenericBox.descr_oct), __hex__ = interp2app(W_GenericBox.descr_hex), __add__ = interp2app(W_GenericBox.descr_add), __sub__ = interp2app(W_GenericBox.descr_sub), __mul__ = interp2app(W_GenericBox.descr_mul), __div__ = interp2app(W_GenericBox.descr_div), __truediv__ = interp2app(W_GenericBox.descr_truediv), __floordiv__ = interp2app(W_GenericBox.descr_floordiv), __mod__ = interp2app(W_GenericBox.descr_mod), __divmod__ = interp2app(W_GenericBox.descr_divmod), __pow__ = interp2app(W_GenericBox.descr_pow), __lshift__ = interp2app(W_GenericBox.descr_lshift), __rshift__ = interp2app(W_GenericBox.descr_rshift), __and__ = interp2app(W_GenericBox.descr_and), __or__ = interp2app(W_GenericBox.descr_or), __xor__ = interp2app(W_GenericBox.descr_xor), __radd__ = interp2app(W_GenericBox.descr_radd), __rsub__ = interp2app(W_GenericBox.descr_rsub), __rmul__ = interp2app(W_GenericBox.descr_rmul), __rdiv__ = interp2app(W_GenericBox.descr_rdiv), __rtruediv__ = interp2app(W_GenericBox.descr_rtruediv), __rfloordiv__ = interp2app(W_GenericBox.descr_rfloordiv), __rmod__ = interp2app(W_GenericBox.descr_rmod), __rdivmod__ = interp2app(W_GenericBox.descr_rdivmod), __rpow__ = interp2app(W_GenericBox.descr_rpow), __rlshift__ = interp2app(W_GenericBox.descr_rlshift), __rrshift__ = interp2app(W_GenericBox.descr_rrshift), __rand__ = interp2app(W_GenericBox.descr_rand), __ror__ = interp2app(W_GenericBox.descr_ror), __rxor__ = interp2app(W_GenericBox.descr_rxor), __eq__ = interp2app(W_GenericBox.descr_eq), __ne__ = interp2app(W_GenericBox.descr_ne), __lt__ = interp2app(W_GenericBox.descr_lt), __le__ = interp2app(W_GenericBox.descr_le), __gt__ = interp2app(W_GenericBox.descr_gt), __ge__ = interp2app(W_GenericBox.descr_ge), __pos__ = interp2app(W_GenericBox.descr_pos), __neg__ = interp2app(W_GenericBox.descr_neg), __abs__ = interp2app(W_GenericBox.descr_abs), __invert__ = interp2app(W_GenericBox.descr_invert), __hash__ = interp2app(W_GenericBox.descr_hash), __array_priority__ = GetSetProperty(W_GenericBox.descr___array_priority__), tolist = interp2app(W_GenericBox.item), item = interp2app(W_GenericBox.descr_item), transpose = interp2app(W_GenericBox.descr_transpose), min = interp2app(W_GenericBox.descr_self), max = interp2app(W_GenericBox.descr_self), argmin = interp2app(W_GenericBox.descr_zero), argmax = interp2app(W_GenericBox.descr_zero), sum = interp2app(W_GenericBox.descr_self), prod = interp2app(W_GenericBox.descr_self), any = interp2app(W_GenericBox.descr_any), all = interp2app(W_GenericBox.descr_all), ravel = interp2app(W_GenericBox.descr_ravel), round = interp2app(W_GenericBox.descr_round), conjugate = interp2app(W_GenericBox.descr_conjugate), conj = interp2app(W_GenericBox.descr_conjugate), astype = interp2app(W_GenericBox.descr_astype), view = interp2app(W_GenericBox.descr_view), squeeze = interp2app(W_GenericBox.descr_self), copy = interp2app(W_GenericBox.descr_copy), byteswap = interp2app(W_GenericBox.descr_byteswap), tostring = interp2app(W_GenericBox.descr_tostring), tobytes = interp2app(W_GenericBox.descr_tostring), reshape = interp2app(W_GenericBox.descr_reshape), swapaxes = interp2app(W_GenericBox.descr_swapaxes), nonzero = interp2app(W_GenericBox.descr_nd_nonzero), fill = interp2app(W_GenericBox.descr_fill), dtype = GetSetProperty(W_GenericBox.descr_get_dtype), size = GetSetProperty(W_GenericBox.descr_get_size), itemsize = GetSetProperty(W_GenericBox.descr_get_itemsize), nbytes = GetSetProperty(W_GenericBox.descr_get_itemsize), shape = GetSetProperty(W_GenericBox.descr_get_shape), strides = GetSetProperty(W_GenericBox.descr_get_shape), ndim = GetSetProperty(W_GenericBox.descr_get_ndim), T = GetSetProperty(W_GenericBox.descr_self), real = GetSetProperty(W_GenericBox.descr_get_real), imag = GetSetProperty(W_GenericBox.descr_get_imag), flags = GetSetProperty(W_GenericBox.descr_get_flags), ) W_BoolBox.typedef = TypeDef("numpy.bool_", W_GenericBox.typedef, __new__ = interp2app(W_BoolBox.descr__new__.im_func), __index__ = interp2app(W_BoolBox.descr_index), __reduce__ = interp2app(W_BoolBox.descr_reduce), ) W_NumberBox.typedef = TypeDef("numpy.number", W_GenericBox.typedef, ) W_IntegerBox.typedef = TypeDef("numpy.integer", W_NumberBox.typedef, ) W_SignedIntegerBox.typedef = TypeDef("numpy.signedinteger", W_IntegerBox.typedef, ) W_UnsignedIntegerBox.typedef = TypeDef("numpy.unsignedinteger", W_IntegerBox.typedef, ) W_Int8Box.typedef = TypeDef("numpy.int8", W_SignedIntegerBox.typedef, __new__ = interp2app(W_Int8Box.descr__new__.im_func), __index__ = interp2app(W_Int8Box.descr_index), __reduce__ = interp2app(W_Int8Box.descr_reduce), ) W_UInt8Box.typedef = TypeDef("numpy.uint8", W_UnsignedIntegerBox.typedef, __new__ = interp2app(W_UInt8Box.descr__new__.im_func), __index__ = interp2app(W_UInt8Box.descr_index), __reduce__ = interp2app(W_UInt8Box.descr_reduce), ) W_Int16Box.typedef = TypeDef("numpy.int16", W_SignedIntegerBox.typedef, __new__ = interp2app(W_Int16Box.descr__new__.im_func), __index__ = interp2app(W_Int16Box.descr_index), __reduce__ = interp2app(W_Int16Box.descr_reduce), ) W_UInt16Box.typedef = TypeDef("numpy.uint16", W_UnsignedIntegerBox.typedef, __new__ = interp2app(W_UInt16Box.descr__new__.im_func), __index__ = interp2app(W_UInt16Box.descr_index), __reduce__ = interp2app(W_UInt16Box.descr_reduce), ) W_Int32Box.typedef = TypeDef("numpy.int32", (W_SignedIntegerBox.typedef,) + MIXIN_32, __new__ = interp2app(W_Int32Box.descr__new__.im_func), __index__ = interp2app(W_Int32Box.descr_index), __reduce__ = interp2app(W_Int32Box.descr_reduce), ) W_UInt32Box.typedef = TypeDef("numpy.uint32", W_UnsignedIntegerBox.typedef, __new__ = interp2app(W_UInt32Box.descr__new__.im_func), __index__ = interp2app(W_UInt32Box.descr_index), __reduce__ = interp2app(W_UInt32Box.descr_reduce), ) W_Int64Box.typedef = TypeDef("numpy.int64", (W_SignedIntegerBox.typedef,) + MIXIN_64, __new__ = interp2app(W_Int64Box.descr__new__.im_func), __index__ = interp2app(W_Int64Box.descr_index), __reduce__ = interp2app(W_Int64Box.descr_reduce), ) W_UInt64Box.typedef = TypeDef("numpy.uint64", W_UnsignedIntegerBox.typedef, __new__ = interp2app(W_UInt64Box.descr__new__.im_func), __index__ = interp2app(W_UInt64Box.descr_index), __reduce__ = interp2app(W_UInt64Box.descr_reduce), ) W_LongBox.typedef = TypeDef("numpy.int%d" % LONG_BIT, (W_SignedIntegerBox.typedef, W_IntObject.typedef), __new__ = interp2app(W_LongBox.descr__new__.im_func), __index__ = interp2app(W_LongBox.descr_index), __reduce__ = interp2app(W_LongBox.descr_reduce), ) W_ULongBox.typedef = TypeDef("numpy.uint%d" % LONG_BIT, W_UnsignedIntegerBox.typedef, __new__ = interp2app(W_ULongBox.descr__new__.im_func), __index__ = interp2app(W_ULongBox.descr_index), __reduce__ = interp2app(W_ULongBox.descr_reduce), ) W_InexactBox.typedef = TypeDef("numpy.inexact", W_NumberBox.typedef, ) W_FloatingBox.typedef = TypeDef("numpy.floating", W_InexactBox.typedef, ) W_Float16Box.typedef = TypeDef("numpy.float16", W_FloatingBox.typedef, __new__ = interp2app(W_Float16Box.descr__new__.im_func), __reduce__ = interp2app(W_Float16Box.descr_reduce), ) W_Float32Box.typedef = TypeDef("numpy.float32", W_FloatingBox.typedef, __new__ = interp2app(W_Float32Box.descr__new__.im_func), __reduce__ = interp2app(W_Float32Box.descr_reduce), ) W_Float64Box.typedef = TypeDef("numpy.float64", (W_FloatingBox.typedef, W_FloatObject.typedef), __new__ = interp2app(W_Float64Box.descr__new__.im_func), __reduce__ = interp2app(W_Float64Box.descr_reduce), as_integer_ratio = interp2app(W_Float64Box.descr_as_integer_ratio), ) W_ComplexFloatingBox.typedef = TypeDef("numpy.complexfloating", W_InexactBox.typedef, ) W_Complex64Box.typedef = TypeDef("numpy.complex64", (W_ComplexFloatingBox.typedef), __new__ = interp2app(W_Complex64Box.descr__new__.im_func), __reduce__ = interp2app(W_Complex64Box.descr_reduce), __complex__ = interp2app(W_GenericBox.item), ) W_Complex128Box.typedef = TypeDef("numpy.complex128", (W_ComplexFloatingBox.typedef, W_ComplexObject.typedef), __new__ = interp2app(W_Complex128Box.descr__new__.im_func), __reduce__ = interp2app(W_Complex128Box.descr_reduce), ) if long_double_size in (8, 12, 16): W_FloatLongBox.typedef = TypeDef("numpy.float%d" % (long_double_size * 8), (W_FloatingBox.typedef), __new__ = interp2app(W_FloatLongBox.descr__new__.im_func), __reduce__ = interp2app(W_FloatLongBox.descr_reduce), ) W_ComplexLongBox.typedef = TypeDef("numpy.complex%d" % (long_double_size * 16), (W_ComplexFloatingBox.typedef, W_ComplexObject.typedef), __new__ = interp2app(W_ComplexLongBox.descr__new__.im_func), __reduce__ = interp2app(W_ComplexLongBox.descr_reduce), __complex__ = interp2app(W_GenericBox.item), ) W_FlexibleBox.typedef = TypeDef("numpy.flexible", W_GenericBox.typedef, ) W_VoidBox.typedef = TypeDef("numpy.void", W_FlexibleBox.typedef, __new__ = interp2app(W_VoidBox.descr__new__.im_func), __getitem__ = interp2app(W_VoidBox.descr_getitem), __setitem__ = interp2app(W_VoidBox.descr_setitem), __iter__ = interp2app(W_VoidBox.descr_iter), ) W_CharacterBox.typedef = TypeDef("numpy.character", W_FlexibleBox.typedef, ) W_StringBox.typedef = TypeDef("numpy.bytes_", (W_CharacterBox.typedef, W_BytesObject.typedef), __new__ = interp2app(W_StringBox.descr__new__string_box.im_func), __len__ = interp2app(W_StringBox.descr_len), ) W_UnicodeBox.typedef = TypeDef("numpy.str_", (W_CharacterBox.typedef, W_UnicodeObject.typedef), __new__ = interp2app(W_UnicodeBox.descr__new__unicode_box.im_func), __len__ = interp2app(W_UnicodeBox.descr_len), ) W_ObjectBox.typedef = TypeDef("numpy.object_", W_ObjectBox.typedef, __new__ = interp2app(W_ObjectBox.descr__new__.im_func), __getattr__ = interp2app(W_ObjectBox.descr__getattr__), )