def random(localization, proxy_obj, arguments): # if len(arguments) == 0: # return float() # # dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['size'], { # 'size': [Integer, IterableDataStructureWithTypedElements(Integer)], # }, 'random', 0) # # if isinstance(dvar, StypyTypeError): # return dvar # # if call_utilities.is_iterable(arguments[0]): # inner_array = call_utilities.create_numpy_array(numpy.float64()) # return call_utilities.create_numpy_array(inner_array) # # return float() if len(arguments) == 0: return float() dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['size'], { 'size': [Integer, IterableDataStructureWithTypedElements(Integer)], }, 'random', 0) if isinstance(dvar, StypyTypeError): return dvar if call_utilities.is_iterable(arguments[0]): inner_array = call_utilities.create_numpy_array_n_dimensions(numpy.float64(), call_utilities.get_dimensions(localization, arguments[0])) return call_utilities.create_numpy_array(inner_array) return call_utilities.create_numpy_array(numpy.float64())
def any(localization, proxy_obj, arguments): if Number == type(arguments[0]): return numpy.bool_() dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, ['axis', 'out', 'keepdims'], { 'axis': [ types.NoneType, Integer, IterableDataStructureWithTypedElements(Integer) ], 'out': numpy.ndarray, 'keepdims': bool }, 'any') if isinstance(dvar, StypyTypeError): return dvar if 'out' in dvar.keys(): set_contained_elements_type(localization, dvar['out'], numpy.bool_()) return dvar['out'] if 'axis' in dvar.keys(): return call_utilities.create_numpy_array(numpy.bool_()) return numpy.bool_()
def trace(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, ['offset', 'axis1', ' axis2', 'dtype', 'out'], { 'offset': Integer, 'axis1': Integer, 'axis2': Integer, 'dtype': type, 'out': numpy.ndarray, }, 'trace') if isinstance(dvar, StypyTypeError): return dvar dim = call_utilities.get_dimensions(localization, arguments[0]) if dim == 1: return call_utilities.cast_to_numpy_type( get_contained_elements_type(localization, arguments[0])) else: ret = call_utilities.create_numpy_array( call_utilities.get_inner_type(localization, arguments[0])) if 'out' in dvar.keys(): if dim == 1 or not (call_utilities.get_dimensions( localization, dvar['out']) == 1): return StypyTypeError( localization, "Wrong dimensions of out parameter in trace call") set_contained_elements_type( localization, dvar['out'], get_contained_elements_type(localization, arguments[0])) return dvar['out'] return ret
def clip(localization, proxy_obj, arguments): if Number == type(arguments[0]): return call_utilities.cast_to_numpy_type(arguments[0]) dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, ['a_min', 'a_max', 'out'], { 'a_min': [ Integer, IterableDataStructureWithTypedElements(Integer), types.NoneType ], 'a_max': [ Integer, IterableDataStructureWithTypedElements(Integer), types.NoneType ], 'out': numpy.ndarray, }, 'clip') if isinstance(dvar, StypyTypeError): return dvar if 'out' in dvar.keys(): set_contained_elements_type( localization, dvar['out'], get_contained_elements_type(localization, arguments[0])) return dvar['out'] return call_utilities.create_numpy_array( get_contained_elements_type(localization, arguments[0]))
def randint(localization, proxy_obj, arguments): if len(arguments) == 1: return int() dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, ['high', 'size', 'dtype'], { 'high': Integer, 'size': [Integer, IterableDataStructureWithTypedElements(Integer)], 'dtype': type, }, 'randint', 1) if isinstance(dvar, StypyTypeError): return dvar if 'dtype' in dvar: if not Integer == dvar['dtype']: return StypyTypeError( localization, "Unsupported type {0} for randint".format( str(dvar['dtype']))) if 'size' in dvar: return call_utilities.create_numpy_array(numpy.int32()) return int()
def fromarrays(localization, proxy, arguments): dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, [ 'dtype', 'shape', 'formats', 'names', 'titles', 'aligned', 'byteorder' ], { 'dtype': type, 'shape': AnyType, 'formats': AnyType, 'names': [Str, IterableDataStructureWithTypedElements(Str)], 'titles': [Str, IterableDataStructureWithTypedElements(Str)], 'aligned': bool, 'byteorder': AnyType }, 'fromarrays') if isinstance(dvar, StypyTypeError): return dvar arr = arguments[0] contained = get_contained_elements_type(arr) if isinstance(contained, union_type.UnionType): contained = contained.types try: return numpy.core.records.fromarrays(contained, dvar) except Exception as ex: return DynamicType
def MaskedArray(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['mask'], { 'mask': IterableDataStructure, }, 'MaskedArray') if isinstance(dvar, StypyTypeError): return dvar # import numpy # x = numpy.ndarray([1]) # mx = numpy.ma.masked_array(x, mask=[0]) # return mx # # t = call_utilities.get_inner_type(localization, arguments[0]) # # t = 0.0 # # # # return numpy.ma.masked_array(numpy.ndarray(t), [True], t) # arr1 = call_utilities.create_numpy_array_n_dimensions( # call_utilities.cast_to_numpy_type(call_utilities.get_inner_type(localization, arguments[0])), # call_utilities.get_dimensions(localization, arguments[0]), call_utilities.get_inner_type(localization, arguments[0]), False) # # if 'mask' in dvar.keys(): # arr2 = call_utilities.create_numpy_array_n_dimensions( # call_utilities.cast_to_numpy_type(call_utilities.get_inner_type(localization, dvar['mask'])), # call_utilities.get_dimensions(localization, dvar['mask']), call_utilities.get_inner_type(localization, arguments[0]), False) # # arr = numpy.ma.masked_array(arr1, arr2) # else: # arr = numpy.ma.masked_array(arr1) # # return arr mask = call_utilities.wrap_contained_type(numpy.ma.core.MaskedArray(arguments[0], mask=[False])) mask.set_contained_type(mask.wrapped_type.min()) return mask
def uniform(localization, proxy_obj, arguments): if len(arguments) == 0: return float() dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, ['low', 'high', 'size'], { 'low': [ RealNumber, IterableDataStructureWithTypedElements(RealNumber) ], 'high': [ RealNumber, IterableDataStructureWithTypedElements(RealNumber) ], 'size': [Integer, IterableDataStructureWithTypedElements(Integer)], }, 'uniform', 0) if isinstance(dvar, StypyTypeError): return dvar if call_utilities.check_parameter_type(dvar, 'low', IterableDataStructureWithTypedElements(RealNumber)) or \ call_utilities.check_parameter_type(dvar, 'high', IterableDataStructureWithTypedElements(RealNumber)) or \ call_utilities.check_parameter_type(dvar, 'size', IterableDataStructureWithTypedElements(RealNumber)): return call_utilities.create_numpy_array(numpy.float64()) if 'size' in dvar.keys(): return call_utilities.create_numpy_array(numpy.float64()) return float()
def reciprocal(localization, proxy_obj, arguments, func_name='reciprocal'): dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, ['out', 'where'], { 'out': numpy.ndarray, 'where': numpy.ndarray, }, func_name) if isinstance(dvar, StypyTypeError): return dvar if Number == type(arguments[0]): ret = call_utilities.cast_to_numpy_type(numpy.float64()) else: try: ret = call_utilities.create_numpy_array_n_dimensions( call_utilities.cast_to_numpy_type( call_utilities.get_inner_type(localization, arguments[0])), call_utilities.get_dimensions(localization, arguments[0])) except Exception as ex: return StypyTypeError(localization, str(ex)) if 'out' in dvar.keys(): set_contained_elements_type(localization, dvar['out'], ret) return dvar['out'] return ret
def zeros_like(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['dtype', 'order', 'subok'], { 'dtype': type, 'order': Str, 'subok': bool, }, 'ones') if isinstance(dvar, StypyTypeError): return dvar if 'dtype' in dvar.keys(): dtype = dvar['dtype'] else: dtype = None t = call_utilities.check_possible_values(dvar, 'order', ['C', 'F', 'A', 'K']) if isinstance(t, StypyTypeError): return t if Number == type(arguments[0]): return call_utilities.create_numpy_array(arguments[0], dtype=dtype) else: dims = call_utilities.get_dimensions(localization, arguments[0]) typ = call_utilities.create_numpy_array_n_dimensions(call_utilities.get_inner_type(localization, arguments[0]), dims, dtype=dtype) return typ
def nansum(localization, proxy_obj, arguments): if Number == type(arguments[0]): return call_utilities.cast_to_numpy_type(arguments[0]) dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, ['axis', 'dtype', 'out', 'keepdims'], { 'axis': int, 'dtype': type, 'out': numpy.ndarray, 'keepdims': bool }, 'nansum') if isinstance(dvar, StypyTypeError): return dvar if 'out' in dvar.keys(): set_contained_elements_type( localization, dvar['out'], get_contained_elements_type(localization, arguments[0])) return dvar['out'] if 'axis' in dvar.keys(): return call_utilities.create_numpy_array( get_contained_elements_type(localization, arguments[0])) return call_utilities.cast_to_numpy_type( get_contained_elements_type(localization, arguments[0]))
def ones(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['dtype', 'order'],{ 'dtype': type, 'order': Str, }, 'ones') if isinstance(dvar, StypyTypeError): return dvar if 'dtype' in dvar.keys(): dtype = dvar['dtype'] else: dtype = None t = call_utilities.check_possible_values(dvar, 'order', ['C', 'F']) if isinstance(t, StypyTypeError): return t if Number == type(arguments[0]): return call_utilities.create_numpy_array(numpy.float64(), dtype=dtype) else: dims = call_utilities.get_dimensions(localization, arguments[0]) typ = call_utilities.create_numpy_array(numpy.float64(), dtype=dtype) for i in range(dims): typ = call_utilities.create_numpy_array(typ) return typ
def zeros(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, ['dtype', 'order'], { 'dtype': [type, IterableDataStructure], 'order': Str, }, 'zeros') if isinstance(dvar, StypyTypeError): return dvar if 'dtype' in dvar.keys(): dtype = dvar['dtype'] else: dtype = None t = call_utilities.check_possible_values(dvar, 'order', ['C', 'F']) if isinstance(t, StypyTypeError): return t if Number == type(arguments[0]): return call_utilities.create_numpy_array(numpy.float64(), dtype=dtype) else: if call_utilities.is_iterable(dtype): tup = call_utilities.wrap_contained_type(tuple()) tup.set_contained_type(numpy.float64()) contents = call_utilities.create_numpy_array(tup) return call_utilities.create_numpy_array(contents) dims = call_utilities.get_dimensions(localization, arguments[0]) typ = call_utilities.create_numpy_array_n_dimensions( numpy.float64(), dims, dtype=dtype) return typ
def astype(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['dtype', 'order', 'casting', 'subok', 'copy'], { 'dtype': type, 'order': Str, 'casting': Str, 'subok': bool, 'copy': bool, }, 'astype', 0) if isinstance(dvar, StypyTypeError): return dvar dvar = call_utilities.check_possible_values(dvar, 'order', ['C', 'F', 'A', 'K']) if isinstance(dvar, StypyTypeError): return dvar dvar = call_utilities.check_possible_values(dvar, 'casting', ['no', 'equiv', 'safe', 'same_kind', 'unsafe']) if isinstance(dvar, StypyTypeError): return dvar r = TypeWrapper.get_wrapper_of(proxy_obj.__self__) dims = call_utilities.get_dimensions(localization, r) if dims > 1: return call_utilities.create_numpy_array_n_dimensions( call_utilities.get_contained_elements_type(localization, r), dims - 1, dvar['dtype']) else: return call_utilities.create_numpy_array(call_utilities.get_contained_elements_type(localization, r), dvar['dtype'])
def unique(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['return_index', 'return_inverse', 'return_counts'], { 'return_index': bool, 'return_inverse': bool, 'return_counts': bool, }, 'unique') if isinstance(dvar, StypyTypeError): return dvar if Number == type(arguments[0]): ret_arr = call_utilities.create_numpy_array(arguments[0]) else: ret_arr = call_utilities.create_numpy_array(get_contained_elements_type(localization, arguments[0])) if len(dvar.keys()) == 0: return ret_arr tup = wrap_type(tuple()) union = UnionType.add(ret_arr, call_utilities.create_numpy_array(numpy.int32())) if len(dvar.keys()) == 1: set_contained_elements_type(localization, tup, union) if len(dvar.keys()) == 2: union = UnionType.add(union, call_utilities.create_numpy_array(numpy.int32())) set_contained_elements_type(localization, tup, union) if len(dvar.keys()) == 3: union = UnionType.add(union, call_utilities.create_numpy_array(numpy.int32())) union = UnionType.add(union, call_utilities.create_numpy_array(numpy.int32())) set_contained_elements_type(localization, tup, union) return tup
def fit(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, ['domain', 'rcond', 'full', 'w', 'window'], { 'domain': IterableDataStructure, 'rcond': RealNumber, 'full': bool, 'w': IterableDataStructure, 'window': IterableDataStructure, }, 'fit', 3) if isinstance(dvar, StypyTypeError): return dvar ret = call_utilities.create_numpy_array_n_dimensions( call_utilities.get_inner_type(localization, arguments[0]), call_utilities.get_dimensions(localization, arguments[0])) ret = numpy.polynomial.Chebyshev(ret.get_wrapped_type()) if 'full' in dvar.keys(): tup = wrap_contained_type(tuple()) ld = wrap_contained_type(list()) ld.set_contained_type( call_utilities.get_inner_type(localization, arguments[0])) un = UnionType.add(ret, ld) tup.set_contained_type(un) return tup return ret
def dot(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, ['out'], { 'out': numpy.ndarray, }, 'dot') if isinstance(dvar, StypyTypeError): return dvar if Number == type(arguments[0]) and Number == type(arguments[1]): return call_utilities.cast_to_greater_numpy_type( arguments[0], arguments[1]) if Number == type(arguments[0]) and call_utilities.is_iterable( arguments[1]): c_t = get_contained_elements_type(localization, arguments[1]) if not 'out' in dvar.keys(): return call_utilities.create_numpy_array(c_t) else: set_contained_elements_type(localization, dvar['out'], c_t) return dvar['out'] if Number == type(arguments[1]) and call_utilities.is_iterable( arguments[0]): c_t = get_contained_elements_type(localization, arguments[0]) if not 'out' in dvar.keys(): return call_utilities.create_numpy_array(c_t) else: set_contained_elements_type(localization, dvar['out'], c_t) return dvar['out'] if call_utilities.is_iterable( arguments[0]) and call_utilities.is_iterable(arguments[1]): if call_utilities.get_dimensions( localization, arguments[0]) == 1 and call_utilities.get_dimensions( localization, arguments[1]) == 1: return call_utilities.cast_to_greater_numpy_type( call_utilities.get_inner_type(localization, arguments[0]), call_utilities.get_inner_type(localization, arguments[1])) typ = call_utilities.cast_to_greater_numpy_type( call_utilities.get_inner_type(localization, arguments[0]), call_utilities.get_inner_type(localization, arguments[1])) for i in range( call_utilities.get_dimensions(localization, arguments[0])): typ = call_utilities.create_numpy_array(typ) if not 'out' in dvar.keys(): return typ else: set_contained_elements_type( localization, dvar['out'], get_contained_elements_type(localization, typ)) return dvar['out'] return arguments[0]
def einsum(localization, proxy_obj, arguments): if isinstance(arguments[-1], dict): if Str == type(arguments[0]): arg_num = 2 else: arg_num = 1 dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['out', 'dtype', 'order', 'casting', 'optimize'], { 'out': IterableDataStructure, 'dtype': type, 'order': Str, 'casting': Str, 'optimize': [bool, Str] }, 'einsum', arg_num) if isinstance(dvar, StypyTypeError): return dvar val_temp = call_utilities.check_possible_values(dvar, 'order', ['C', 'F', 'A', 'K']) if isinstance(val_temp, StypyTypeError): return val_temp val_temp = call_utilities.check_possible_values(dvar, 'casting', ['no', 'equiv', 'safe', 'same_kind', 'unsafe']) if isinstance(val_temp, StypyTypeError): return val_temp val_temp = call_utilities.check_possible_values(dvar, 'optimize', ['greedy', 'optimal', False, True]) if isinstance(val_temp, StypyTypeError): return val_temp arguments = arguments[:-1] else: dvar = dict() typ = None if Str == type(arguments[0]): arg_list = arguments[1:] if Number == type(arguments[1]) and 'out' in dvar: return dvar['out'] else: arg_list = arguments for arg in arg_list: if call_utilities.is_iterable(arg): typ_temp = call_utilities.cast_to_numpy_type(call_utilities.get_inner_type(localization, arg)) typ = call_utilities.cast_to_greater_numpy_type(typ, typ_temp) union = UnionType.add(typ, call_utilities.create_numpy_array(DynamicType)) if 'out' in dvar: set_contained_elements_type(localization, dvar['out'], DynamicType) return call_utilities.create_numpy_array(DynamicType) return union
def bincount(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, ['weights', 'minlength'], { 'weights': IterableDataStructure, 'minlength': Integer, }, 'bincount') if isinstance(dvar, StypyTypeError): return dvar return call_utilities.create_numpy_array(numpy.int32())
def allclose(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['rtol', 'atol','equal_nan'],{ 'rtol': RealNumber, 'atol': RealNumber, 'equal_nan': bool, }, 'allclose', 2) if isinstance(dvar, StypyTypeError): return dvar return bool()
def gradient(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, ['vargargs', 'edge_order'], { 'varargs': IterableDataStructureWithTypedElements(RealNumber), 'edge_order': Integer, }, 'gradient') if isinstance(dvar, StypyTypeError): return dvar return call_utilities.create_numpy_array( get_contained_elements_type(arguments[0]))
def diff(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['n', 'axis'], { 'n': Integer, 'axis': Integer, }, 'diff') if isinstance(dvar, StypyTypeError): return dvar return call_utilities.create_numpy_array( get_contained_elements_type(arguments[0]))
def trapz(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, ['x', 'dx', 'axis'], { 'x': IterableDataStructureWithTypedElements(RealNumber), 'dx': RealNumber, 'axis': Integer, }, 'trapz') if isinstance(dvar, StypyTypeError): return dvar return numpy.float64()
def tensordot(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['axes'],{ 'axes': [Integer, IterableDataStructureWithTypedElements(Integer)], }, 'tensordot', 2) if isinstance(dvar, StypyTypeError): return dvar l = wrap_contained_type(list()) set_contained_elements_type(localization, l, DynamicType()) return call_utilities.create_numpy_array(l)
def count_nonzero(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['axis'], { 'axis': Integer, }, 'count_nonzero') if isinstance(dvar, StypyTypeError): return dvar if 'axis' in dvar.keys(): return call_utilities.create_numpy_array(numpy.int64()) else: return numpy.int64()
def ediff1d(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['to_end', 'to_begin'], { 'to_end': IterableDataStructure, 'to_begin': IterableDataStructure, }, 'ediff1d') if isinstance(dvar, StypyTypeError): return dvar if Number == type(arguments[0]): return call_utilities.create_numpy_array(arguments[0]) else: return call_utilities.create_numpy_array(get_contained_elements_type(localization, arguments[0]))
def rollaxis(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['shift', 'axis'], { 'shift': [Integer, IterableDataStructureWithTypedElements(Integer)], 'axis': [Integer, IterableDataStructureWithTypedElements(Integer)], }, 'rollaxis', 2) if isinstance(dvar, StypyTypeError): return dvar t = call_utilities.get_inner_type(localization, arguments[0]) if not Number == type(t): return StypyTypeError(localization, "The contents of the passed array are not numeric") return arguments[0]
def lookfor(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, ['module', 'import_modules', 'regenerate', 'output'], { 'module': [Str, IterableDataStructureWithTypedElements(Str)], 'import_modules': bool, 'regenerate': bool, 'output': file, }, 'lookfor') if isinstance(dvar, StypyTypeError): return dvar return types.NoneType
def divide(localization, proxy_obj, arguments, func_name='divide'): dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, ['out', 'where'], { 'out': numpy.ndarray, 'where': numpy.ndarray, }, func_name, 2) if isinstance(dvar, StypyTypeError): return dvar if Number == type(arguments[0]) and Number == type(arguments[1]): return call_utilities.cast_to_greater_numpy_type( arguments[0], arguments[1]) try: dims = 0 if call_utilities.is_iterable(arguments[0]): param0 = call_utilities.get_inner_type(localization, arguments[0]) dims = call_utilities.get_dimensions(localization, arguments[0]) else: param0 = arguments[0] if call_utilities.is_iterable(arguments[1]): param1 = call_utilities.get_inner_type(localization, arguments[1]) temp = call_utilities.get_dimensions(localization, arguments[1]) if temp > dims: dims = temp else: param1 = arguments[1] if dims > 0: ret = call_utilities.create_numpy_array_n_dimensions( call_utilities.cast_to_greater_numpy_type(param0, param1), dims) else: ret = call_utilities.cast_to_greater_numpy_type(param0, param1) except Exception as ex: return StypyTypeError(localization, str(ex)) if 'out' in dvar.keys(): set_contained_elements_type(localization, dvar['out'], ret) return dvar['out'] return ret
def polyfit(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, ['rcond', 'full', 'w', 'cov'], { 'rcond': RealNumber, 'full': bool, 'w': IterableDataStructure, 'cov': bool, }, 'polyfit', 3) if isinstance(dvar, StypyTypeError): return dvar import numpy return call_utilities.wrap_contained_type( numpy.polyfit(arguments[0].get_wrapped_type(), arguments[1].get_wrapped_type(), arguments[2]))