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 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 iadd(localization, proxy_obj, arguments): if call_utilities.is_iterable( arguments[0]) and call_utilities.is_iterable(arguments[1]): if isinstance( arguments[0].get_wrapped_type(), list) and isinstance( arguments[1].get_wrapped_type(), tuple): t1 = get_contained_elements_type(localization, arguments[0]) t2 = get_contained_elements_type(localization, arguments[1]) tEnd = UnionType.add(t1, t2) set_contained_elements_type(localization, arguments[0], tEnd) return arguments[0] return None
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 is_suitable_for_loop_condition(localization, condition_type): """ A loop must iterate an iterable object or data structure or an string. This function checks this :param localization: Caller information :param condition_type: Type of the condition :return: """ if is_error_type(condition_type): return False if type(condition_type) is RecursionType: return False if type(condition_type) is file: return True if condition_type is undefined_type.UndefinedType: return False if not (can_store_elements(condition_type) or can_represent_type(Str, condition_type) or ( can_represent_type(IterableObject, condition_type)) or call_utilities.is_iterable(condition_type)): StypyTypeError(localization, "The type of this for loop condition is erroneous") return False return True
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 __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 will_iterate_loop(localization, condition_type): """ A loop must iterate an iterable object or data structure or an string. This function checks if the iterable object is empty (its contents are of the type UndefinedType). In that case, it does not iterate :param localization: Caller information :param condition_type: Type of the condition :return: """ if is_error_type(condition_type): return False if type(condition_type) is file: return True if condition_type is undefined_type.UndefinedType: return False if (can_store_elements(condition_type) or ( can_represent_type(IterableObject, condition_type)) or call_utilities.is_iterable(condition_type)): try: Localization.set_current(localization) t = get_contained_elements_type(condition_type) if type(t) is undefined_type.UndefinedType or t is undefined_type.UndefinedType: return False except: pass return True return True
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 add(localization, proxy_obj, arguments): if call_utilities.is_iterable( arguments[0]) and call_utilities.is_iterable(arguments[1]): if isinstance(arguments[0].get_wrapped_type(), tuple) and isinstance( arguments[1].get_wrapped_type(), tuple): t1 = call_utilities.get_contained_elements_type( localization, arguments[0]) t2 = call_utilities.get_contained_elements_type( localization, arguments[1]) if isinstance(t1, UnionType): t1 = t1.duplicate() tEnd = UnionType.add(t1, t2) wrap = call_utilities.wrap_contained_type((tEnd, )) wrap.set_contained_type(tEnd) return wrap return None # Type rule results
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 block(localization, proxy_obj, arguments): union = None for arg in arguments: if call_utilities.is_iterable(arg): union = UnionType.add( union, get_contained_elements_type(localization, arg)) else: union = UnionType.add(union, arg) return call_utilities.create_numpy_array(union)
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 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 dstack(localization, proxy_obj, arguments): elem_list = wrap_contained_type(list()) for arg in arguments: if call_utilities.is_iterable(arg): cont = get_contained_elements_type(localization, arg) if call_utilities.is_iterable(cont): union2 = UnionType.add(elem_list.get_contained_type(), cont.get_contained_type()) elem_list.set_contained_type(union2) else: union2 = UnionType.add(elem_list.get_contained_type(), cont) elem_list.set_contained_type(union2) else: return StypyTypeError( localization, "A non-iterable parameter {0} was passed to the dstack function" .format(str(arg))) return call_utilities.create_numpy_array(elem_list)
def concatenate(localization, proxy_obj, arguments): union = None for arg in arguments: if call_utilities.is_iterable(arg): union = UnionType.add( union, get_contained_elements_type(localization, arg)) else: return StypyTypeError( localization, "A non-iterable parameter {0} was passed to the concatenate function" .format(str(arg))) return call_utilities.create_numpy_array(union)
def hstack(localization, proxy_obj, arguments): union = None for arg in arguments: if call_utilities.is_iterable(arg): union = UnionType.add( union, call_utilities.get_inner_type(localization, arg)) else: return StypyTypeError( localization, "A non-iterable parameter {0} was passed to the hstack function" .format(str(arg))) return call_utilities.create_numpy_array(union)
def ascontiguousarray(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['dtype'],{ 'dtype': type, }, 'ascontiguousarray') if 'dtype' in dvar.keys(): dtype = dvar['dtype'] else: dtype = None if call_utilities.is_iterable(arguments[0]): typ = get_contained_elements_type(localization, arguments[0]) else: typ = arguments[0] return call_utilities.create_numpy_array(typ, dtype=dtype)
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 reshape(localization, proxy_obj, arguments): shape_levels = len(arguments) if Str == type(arguments[-1]): shape_levels -= 1 if shape_levels == 0: return StypyTypeError(localization, "Invalid 'shape' parameter for reshape call: There must be at least one shape element") if call_utilities.is_iterable(arguments[0]): shape_levels = 2 if len(arguments) > 1 and not Str == type(arguments[-1]) and not Integer == type(arguments[-1]): return StypyTypeError(localization, "Invalid 'order' parameter for reshape call: {0}".format(str(arguments[-1]))) r = TypeWrapper.get_wrapper_of(proxy_obj.__self__) contained = r.get_contained_type() for i in range(shape_levels): contained = call_utilities.create_numpy_array(contained) return contained
def stack(localization, proxy_obj, arguments): dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['axis'], { 'axis': Integer, }, 'stack') if isinstance(dvar, StypyTypeError): return dvar union = None for arg in arguments: if call_utilities.is_iterable(arg): union = UnionType.add( union, get_contained_elements_type(localization, arg)) else: return StypyTypeError( localization, "A non-iterable parameter {0} was passed to the stack function" .format(str(arg))) return call_utilities.create_numpy_array(union)
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: if call_utilities.is_iterable(dvar['size']): return call_utilities.create_numpy_array_n_dimensions(numpy.int32(), 2) return call_utilities.create_numpy_array(numpy.int32()) return int()
def bitwise_and(localization, proxy_obj, arguments, func_name='bitwise_and'): dvar = call_utilities.parse_varargs_and_kwargs( localization, arguments, ['where'], { 'where': [Str, IterableDataStructureWithTypedElements(bool)], }, func_name, 2) if isinstance(dvar, StypyTypeError): return dvar if call_utilities.is_iterable( arguments[0]) and call_utilities.is_iterable(arguments[1]): if not call_utilities.check_possible_types( call_utilities.get_inner_type(localization, arguments[0]), [bool, Integer]) or not call_utilities.check_possible_types( call_utilities.get_inner_type(localization, arguments[1]), [bool, Integer]): return StypyTypeError( localization, " ufunc '" + func_name + "' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''" ) if call_utilities.is_numpy_array(arguments[0]): return call_utilities.create_numpy_array( call_utilities.get_inner_type(localization, arguments[0])) if call_utilities.is_numpy_array(arguments[1]): return call_utilities.create_numpy_array( call_utilities.get_inner_type(localization, arguments[1])) return arguments[0] else: if call_utilities.is_iterable( arguments[0]) and not call_utilities.is_iterable( arguments[1]): if not call_utilities.check_possible_types( call_utilities.get_inner_type(localization, arguments[0]), [bool, Integer ]) or not call_utilities.check_possible_types( arguments[1], [bool, Integer]): return StypyTypeError( localization, " ufunc '" + func_name + "' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''" ) if call_utilities.is_numpy_array(arguments[0]): return call_utilities.create_numpy_array( call_utilities.get_inner_type(localization, arguments[0])) return arguments[0] else: if not call_utilities.is_iterable( arguments[0]) and call_utilities.is_iterable( arguments[1]): if not call_utilities.check_possible_types( call_utilities.get_inner_type( localization, arguments[1]), [bool, Integer ]) or not call_utilities.check_possible_types( arguments[0], [bool, Integer]): return StypyTypeError( localization, " ufunc '" + func_name + "' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe''" ) if call_utilities.is_numpy_array(arguments[1]): return call_utilities.create_numpy_array( call_utilities.get_inner_type( localization, arguments[1])) return arguments[1] else: return arguments[0]