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 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 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 __getitem__(localization, proxy_obj, arguments): r = TypeWrapper.get_wrapper_of(proxy_obj.__self__) index_selector = arguments[0] if isinstance(index_selector, tuple): index_selector = index_selector[0] dims = call_utilities.get_dimensions(localization, r) if dims > 1: if call_utilities.is_iterable(arguments[0]): if call_utilities.is_iterable(arguments[0].get_contained_type()): return call_utilities.create_numpy_array_n_dimensions( call_utilities.cast_to_numpy_type(call_utilities.get_inner_type(localization, r)), dims - 1) contained = call_utilities.cast_to_numpy_type(call_utilities.get_inner_type(localization, r)) for i in range(dims - 1): contained = UnionType.add(contained, call_utilities.create_numpy_array_n_dimensions(r.get_contained_type(), i + 1)) else: contained = r.get_contained_type() if isinstance(index_selector, TypeWrapper): if isinstance(index_selector.wrapped_type, slice) or ( call_utilities.is_iterable(index_selector) and not isinstance(index_selector.wrapped_type, tuple)): l = call_utilities.create_numpy_array(contained) return l return contained # proxy_obj.__self__.dtype.type()
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 __div__(localization, proxy_obj, arguments, func_name='__div__'): # 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 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 dims > 0: ret = call_utilities.create_numpy_array_n_dimensions( call_utilities.cast_to_numpy_type(param0), dims) else: ret = call_utilities.create_numpy_array(call_utilities.cast_to_numpy_type(param0)) 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(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 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 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 ne(localization, proxy_obj, arguments): if call_utilities.is_numpy_array( arguments[0]) and call_utilities.is_numpy_array(arguments[1]): return call_utilities.create_numpy_array_n_dimensions( bool(), call_utilities.get_dimensions(localization, arguments[0])) return None # Type rule results
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 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 tile(localization, proxy_obj, arguments): dims = 1 if len(arguments) == 2 and call_utilities.is_iterable(arguments[1]): dims = call_utilities.get_dimensions(localization, arguments[1]) if Number == type(arguments[0]): return call_utilities.create_numpy_array_n_dimensions(arguments[0], dims) return call_utilities.create_numpy_array_n_dimensions(get_contained_elements_type(localization, arguments[0]), dims)
def det(localization, proxy_obj, arguments): param0 = call_utilities.get_inner_type(localization, arguments[0]) dims = call_utilities.get_dimensions(localization, arguments[0]) if dims == 1: return call_utilities.cast_to_numpy_type(param0) else: return call_utilities.create_numpy_array_n_dimensions( call_utilities.cast_to_numpy_type(param0), dims)
def angle(localization, proxy_obj, arguments): if not call_utilities.is_iterable(arguments): return numpy.float64() 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( numpy.float64(), dims - 1) else: return call_utilities.create_numpy_array(numpy.float64())
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_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 atleast_2d(localization, proxy_obj, arguments): rets = list() for arg in arguments: if call_utilities.is_iterable(arg): if call_utilities.get_dimensions(localization, arg) >= 2: rets.append(arg) else: rets.append( call_utilities.create_numpy_array_n_dimensions( call_utilities.get_inner_type(localization, arg), 2)) else: return StypyTypeError( localization, "A non-iterable parameter {0} was passed to the atleast_2d function" .format(str(arg))) if len(rets) == 1: return rets[0] return tuple(rets)
def mean(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['axis', 'dtype', 'out', 'keepdims'], { 'dtype': type, 'axis': Integer, 'out': numpy.ndarray, 'keepdims': bool, }, 'mean', 0) if isinstance(dvar, StypyTypeError): return dvar r = TypeWrapper.get_wrapper_of(proxy_obj.__self__) dims = call_utilities.get_dimensions(localization, r) if 'axis' in dvar: if dims > 1: if 'out' in dvar.keys(): set_contained_elements_type(localization, dvar['out'], numpy.int32()) return dvar['out'] return call_utilities.create_numpy_array(numpy.float64()) return numpy.float64()