def resolve_transpose(self, ary, args, kws): def sentry_shape_scalar(ty): if ty in types.number_domain: # Guard against non integer type if not isinstance(ty, types.Integer): raise TypeError("transpose() arg cannot be {0}".format(ty)) return True else: return False assert not kws if len(args) == 0: return signature(self.resolve_T(ary)) if len(args) == 1: shape, = args if sentry_shape_scalar(shape): assert ary.ndim == 1 return signature(ary, *args) shape = normalize_shape(shape) if shape is None: return assert ary.ndim == shape.count return signature(self.resolve_T(ary), shape) else: if any(not sentry_shape_scalar(a) for a in args): raise TypeError("transpose({0}) is not supported".format( ', '.join(args))) assert ary.ndim == len(args) return signature(self.resolve_T(ary), *args)
def sum_expand(self, args, kws): """ sum can be called with or without an axis parameter. """ pysig = None if kws: def sum_stub(axis): pass pysig = utils.pysignature(sum_stub) # rewrite args args = list(args) + [kws['axis']] kws = None args_len = len(args) assert args_len <= 1 if args_len == 0: # No axis parameter so the return type of the summation is a scalar # of the type of the array. out = signature(_expand_integer(self.this.dtype), *args, recvr=self.this) else: # There is an axis paramter so the return type of this summation is # an array of dimension one less than the input array. return_type = types.Array(dtype=_expand_integer(self.this.dtype), ndim=self.this.ndim-1, layout='C') out = signature(return_type, *args, recvr=self.this) return out.replace(pysig=pysig)
def generic(self, args, kws): assert not kws (val,) = args if isinstance(val, (types.Buffer, types.BaseTuple)): return signature(types.intp, val) elif isinstance(val, (types.RangeType)): return signature(val.dtype, val)
def generic_hetero_always_real(self, args, kws): assert not args assert not kws if isinstance(self.this.dtype, (types.Integer, types.Boolean)): return signature(types.float64, recvr=self.this) if isinstance(self.this.dtype, types.Complex): return signature(self.this.dtype.underlying_float, recvr=self.this) return signature(self.this.dtype, recvr=self.this)
def generic(self, args, kws): assert not kws ary, idx, val = args if ary.ndim == 1: return signature(ary.dtype, ary, types.intp, ary.dtype) elif ary.ndim > 1: return signature(ary.dtype, ary, idx, ary.dtype)
def generic_expand(self, args, kws): if isinstance(self.this.dtype, types.Integer): # Expand to a machine int, not larger (like Numpy) if self.this.dtype.signed: return signature(max(types.intp, self.this.dtype), recvr=self.this) else: return signature(max(types.uintp, self.this.dtype), recvr=self.this) return signature(self.this.dtype, recvr=self.this)
def generic(self, args, kws): assert not kws # empty tuple case if len(args) == 0: return signature(types.Tuple(())) (val,) = args # tuple as input if isinstance(val, types.BaseTuple): return signature(val, val)
def generic(self, args, kws): assert not kws [arg] = args if isinstance(arg, types.Integer): return signature(arg, arg) if isinstance(arg, (types.Float, types.Boolean)): return signature(types.intp, arg)
def generic(self, args, kws): if len(args) == 1: # Guard against unary + and - return left, right = args if not all(isinstance(tp, types.NPTimedelta) for tp in args): return if npdatetime.can_cast_timedelta_units(left.unit, right.unit): return signature(right, left, right) elif npdatetime.can_cast_timedelta_units(right.unit, left.unit): return signature(left, left, right)
def generic(self, args, kws): assert not kws nargs = len(args) if nargs == 2: [inp, out] = args if isinstance(inp, types.Array) and isinstance(out, types.Array): return signature(out, inp, out) elif nargs == 1: [inp] = args if inp in types.number_domain: return signature(types.float64, types.float64)
def generic(self, args, kws): assert not kws ary, idx, val = args # Implementation presently supports float64 only, # so fail typing otherwise if ary.dtype != types.float64: return if ary.ndim == 1: return signature(ary.dtype, ary, types.intp, ary.dtype) elif ary.ndim > 1: return signature(ary.dtype, ary, idx, ary.dtype)
def generic(self, args, kws): assert not kws ary, idx, val = args if not isinstance(ary, types.Buffer): return if not ary.mutable: raise TypeError("Cannot modify value of type %s" %(ary,)) out = get_array_index_type(ary, idx) if out is None: return idx = out.index res = out.result if isinstance(res, types.Array): # Indexing produces an array if isinstance(val, types.Array): if not self.context.can_convert(val.dtype, res.dtype): # DType conversion not possible return else: res = val elif isinstance(val, types.Sequence): if (res.ndim == 1 and self.context.can_convert(val.dtype, res.dtype)): # Allow assignement of sequence to 1d array res = val else: # NOTE: sequence-to-array broadcasting is unsupported return else: # Allow scalar broadcasting if self.context.can_convert(val, res.dtype): res = res.dtype else: # Incompatible scalar type return elif not isinstance(val, types.Array): # Single item assignment if not self.context.can_convert(val, res): # if the array dtype is not yet defined if not res.is_precise(): # set the array type to use the dtype of value (RHS) newary = ary.copy(dtype=val) return signature(types.none, newary, idx, res) else: return res = val else: return return signature(types.none, ary, idx, res)
def resolve_take(self, ary, args, kws): assert not kws argty, = args if isinstance(argty, types.Integer): sig = signature(ary.dtype, *args) elif isinstance(argty, types.Array): sig = signature(argty.copy(layout='C', dtype=ary.dtype), *args) elif isinstance(argty, types.List): # 1d lists only sig = signature(types.Array(ary.dtype, 1, 'C'), *args) elif isinstance(argty, types.BaseTuple): sig = signature(types.Array(ary.dtype, np.ndim(argty), 'C'), *args) else: raise TypeError("take(%s) not supported for %s" % argty) return sig
def generic(self, args, kws): # Resolution of members for record and structured arrays record, idx, value = args if isinstance(record, types.Record) and isinstance(idx, str): expectedty = record.typeof(idx) if self.context.can_convert(value, expectedty) is not None: return signature(types.void, record, types.Const(idx), value)
def generic(self, args, kws): assert not kws [arg] = args if arg not in types.number_domain: raise TypeError("float() only support for numbers") if arg in types.complex_domain: raise TypeError("float() does not support complex") if arg in types.integer_domain: return signature(types.float64, arg) elif arg in types.real_domain: return signature(arg, arg)
def resolve_itemset(self, ary, args, kws): assert not kws # We don't support explicit arguments as that's exactly equivalent # to regular indexing. The no-argument form is interesting to # allow some degree of genericity when writing functions. if len(args) == 1: return signature(types.none, ary.dtype)
def generic(self, args, kws): assert not kws if len(args) == 1: [arg] = args if arg not in types.number_domain: raise TypeError("complex() only support for numbers") return signature(types.complex128, arg) elif len(args) == 2: [real, imag] = args if (real not in types.number_domain or imag not in types.number_domain): raise TypeError("complex() only support for numbers") return signature(types.complex128, real, imag)
def generic(self, args, kws): assert not kws [ary, idx] = args if not isinstance(ary, types.Array): return idx = normalize_index(idx) if not idx: return if idx == types.slice3_type: #(types.slice2_type, types.slice3_type): res = ary.copy(layout='A') elif isinstance(idx, (types.UniTuple, types.Tuple)): if ary.ndim > len(idx): return elif ary.ndim < len(idx): return elif any(i == types.slice3_type for i in idx): ndim = ary.ndim for i in idx: if i != types.slice3_type: ndim -= 1 res = ary.copy(ndim=ndim, layout='A') else: res = ary.dtype elif idx == types.intp: if ary.ndim != 1: return res = ary.dtype else: raise Exception("unreachable: index type of %s" % idx) return signature(res, ary, idx)
def generic(self, args, kws): assert not args assert not kws this = self.this if this.layout == 'C': resty = this.copy(ndim=1) return signature(resty, recvr=this)
def generic(self, args, kws): assert not kws ary, idx, val = args if not isinstance(ary, types.Buffer): return if not ary.mutable: raise TypeError("Cannot modify value of type %s" %(ary,)) out = get_array_index_type(ary, idx) if out is None: return idx = out.index res = out.result if isinstance(res, types.Array): # Indexing produces an array if not isinstance(val, types.Array): # Allow scalar broadcasting res = res.dtype elif (val.ndim == res.ndim and self.context.can_convert(val.dtype, res.dtype)): # Allow assignement of same-dimensionality compatible-dtype array res = val else: # Unexpected dimensionality of assignment source # (array broadcasting is unsupported) return elif not isinstance(val, types.Array): # Single item assignment res = val else: return return signature(types.none, ary, idx, res)
def resolve_view(self, ary, args, kws): from .npydecl import _parse_dtype assert not kws dtype, = args dtype = _parse_dtype(dtype) retty = ary.copy(dtype=dtype) return signature(retty, *args)
def generic(self, args, kws): assert not kws if len(args) == 1: # One-argument type() -> return the __class__ classty = self.context.resolve_getattr(args[0], "__class__") if classty is not None: return signature(classty, *args)
def generic(self, args, kws): assert not kws ary, idx, val = args if isinstance(ary, types.Buffer): if not ary.mutable: raise TypeError("Immutable array") return signature(types.none, ary, normalize_index(idx), ary.dtype)
def generic(self, args, kws): for a in args: sig = self.context.resolve_function_type("print_item", (a,), {}) if sig is None: raise TypeError("Type %s is not printable." % a) assert sig.return_type is types.none return signature(types.none, *args)
def generic(self, args, kws): assert not kws args = args[::-1] if self.reverse_args else args sig = self.context.resolve_function_type(self.op, args, kws) if self.reverse_args and sig is not None: sig = signature(sig.return_type, *sig.args[::-1]) return sig
def resolve_nonzero(self, ary, args, kws): assert not args assert not kws # 0-dim arrays return one result array ndim = max(ary.ndim, 1) retty = types.UniTuple(types.Array(types.intp, 1, 'C'), ndim) return signature(retty)
def generic(self, args, kws): assert not kws ary, idx, val = args # Implementation presently supports: # float64, float32, int32, int64, uint32, uint64 only, # so fail typing otherwise supported_types = (types.float64, types.float32, types.int32, types.uint32, types.int64, types.uint64) if ary.dtype not in supported_types: return if ary.ndim == 1: return signature(ary.dtype, ary, types.intp, ary.dtype) elif ary.ndim > 1: return signature(ary.dtype, ary, idx, ary.dtype)
def generic(self, args, kws): assert not kws [ary, idx] = args out = get_array_index_type(ary, idx) if out is not None: ary, idx, res = out return signature(res, ary, idx)
def generic(self, args, kws): assert not kws ary, old, val = args dty = ary.dtype # only support int32 if dty == types.int32 and ary.ndim == 1: return signature(dty, ary, dty, dty)
def generic(self, args, kws): assert not kws ary, idx, val = args if isinstance(ary, types.Array): if ary.const: raise TypeError("Constant array") return signature(types.none, ary, normalize_index(idx), ary.dtype)
def generic(self, args, kws): arg, = args if self.is_accepted_type(arg): return signature(types.none, *args)
def generic(self, args, kws): sig = signature(mnb_type, types.intp) pysig = utils.pysignature(MultinomialNB_dummy) sig.pysig = pysig return sig
def resolve_train(self, dict, args, kws): assert not kws assert len(args) == 2 return signature(types.none, *args)
class UnorderedCmpOp(ConcreteTemplate): cases = OrderedCmpOp.cases + [ signature(types.boolean, op, op) for op in sorted(types.complex_domain) ]
def generic(self, args, kws): assert not kws if len(args) == 1: it = args[0] if isinstance(it, types.IteratorType): return signature(it.yield_type, *args)
def generic(self, args, kws): assert not kws assert len(args) == 1 assert isinstance(args[0], (types.DType, types.NumberClass)) return signature(args[0].dtype, *args)
def generic(self, args, kws): assert not kws [pair] = args if isinstance(pair, types.Pair): return signature(pair.second_type, pair)
class BinOpFloorDiv(ConcreteTemplate): cases = list(integer_binop_cases) cases += [signature(op, op, op) for op in sorted(types.real_domain)]
class DivMod(ConcreteTemplate): _tys = machine_ints + sorted(types.real_domain) cases = [signature(types.UniTuple(ty, 2), ty, ty) for ty in _tys]
def generic(self, args, kws): assert not kws ary, idx, val = args if ary == string_array_type: return signature(types.none, *args)
def generic(self, args, kws): arg, = args return signature(types.none, *args)
def generic(self, args, kws): assert not kws [obj] = args if isinstance(obj, types.IterableType): return signature(obj.iterator_type, obj)
def resolve_copy(self, ary, args, kws): return signature(string_array_type, *args)
def generic(self, args, kws): assert not kws if all(isinstance(it, types.IterableType) for it in args): zip_type = types.ZipType(args) return signature(zip_type, *args)
def resolve_item(self, ty, args, kws): assert not kws if not args: return signature(ty)
def generic(self, args, kws): assert not kws arg, = args if isinstance(arg, types.Hashable): return signature(types.intp, *args)
def generic(self, args, kws): args = args[::-1] sig = self.context.resolve_function_type(operator.contains, args, kws) return signature(sig.return_type, *sig.args[::-1])
def resolve_conjugate(self, ty, args, kws): assert not args assert not kws return signature(ty)
def generic(self, args, kws): assert not kws (seq, val) = args if isinstance(seq, (types.Sequence)): return signature(types.boolean, seq, val)
def generic(self, args, kws): assert not kws (val, ) = args if isinstance(val, (types.BaseTuple)): return signature(types.boolean, val)
def generic(self, args, kws): [lhs, rhs] = args return signature(types.boolean, lhs, rhs)
def generic(self, args, kws): assert not kws ptr, idx, val = args if isinstance(ptr, types.CPointer) and isinstance(idx, types.Integer): return signature(types.none, ptr, normalize_1d_index(idx), ptr.dtype)
def generic(self, args, kws): assert not kws [it] = args if isinstance(it, types.IteratorType): return signature(types.Pair(it.yield_type, types.boolean), it)
def generic(self, args, kws): assert not kws (arg1, arg2) = args if isinstance(arg1, types.Literal) and isinstance(arg2, types.Literal): return signature(types.boolean, arg1, arg2)
according to the integer typing NBEP. """ bitwidth = choose_result_bitwidth(*inputs) signed = any(tp.signed for tp in inputs) return types.Integer.from_bitwidth(bitwidth, signed) # The "machine" integer types to take into consideration for operator typing # (according to the integer typing NBEP) machine_ints = (sorted(set( (types.intp, types.int64))) + sorted(set((types.uintp, types.uint64)))) # Explicit integer rules for binary operators; smaller ints will be # automatically upcast. integer_binop_cases = tuple( signature(choose_result_int(op1, op2), op1, op2) for op1, op2 in itertools.product(machine_ints, machine_ints)) class BinOp(ConcreteTemplate): cases = list(integer_binop_cases) cases += [signature(op, op, op) for op in sorted(types.real_domain)] cases += [signature(op, op, op) for op in sorted(types.complex_domain)] @infer_global(operator.add) class BinOpAdd(BinOp): pass @infer_global(operator.iadd)
def resolve_predict(self, dict, args, kws): assert not kws assert len(args) == 1 return signature(types.Array(types.int32, 1, 'C'), *args)
def generic(self, args, kws): if not kws and len(args) == 1 and args[0] == string_type: return signature(string_array_type, *args)
class BitwiseLogicOperation(BinOp): cases = [signature(types.boolean, types.boolean, types.boolean)] cases += list(integer_binop_cases) unsafe_casting = False