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 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 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 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 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 heappush(localization, proxy_obj, arguments):
ex_type = get_contained_elements_type(localization, arguments[0])
if ex_type is UndefinedType:
u = arguments[1]
else:
u = UnionType.add(ex_type, arguments[1])
set_contained_elements_type(localization, arguments[0], u)
return types.NoneType
def __getitem__(localization, proxy_obj, arguments):
if Integer == type(arguments[0]):
return int()
else:
t = call_utilities.wrap_contained_type(tuple())
set_contained_elements_type(localization, t, int())
return t
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 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 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 logical_xor(localization, proxy_obj, arguments):
dvar = call_utilities.parse_varargs_and_kwargs(
localization, arguments, ['out'], {
'out': numpy.ndarray,
}, 'logical_xor', 2)
if isinstance(dvar, StypyTypeError):
return dvar
if Number == type(arguments[0]) and Number == type(arguments[1]):
return bool()
if 'out' in dvar.keys():
set_contained_elements_type(localization, dvar['out'], bool())
return dvar['out']
return call_utilities.create_numpy_array(bool())
def outer(localization, proxy_obj, arguments):
dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['out'],{
'out': numpy.ndarray,
}, 'outer', 2)
if isinstance(dvar, StypyTypeError):
return dvar
t1 = get_contained_elements_type(localization, arguments[0])
t2 = get_contained_elements_type(localization, arguments[1])
l = wrap_contained_type(list())
set_contained_elements_type(localization, l, call_utilities.cast_to_greater_numpy_type(t1, t2))
if 'out' in dvar:
set_contained_elements_type(localization, dvar['out'], l)
return call_utilities.create_numpy_array(l)
def argmin(localization, proxy_obj, arguments):
if len(arguments) == 0:
return numpy.int32()
dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['axis', 'out'], {
'axis': Integer,
'out': numpy.ndarray,
}, 'argmin', 0)
if isinstance(dvar, StypyTypeError):
return dvar
if 'out' in dvar.keys():
set_contained_elements_type(localization, dvar['out'], numpy.int32())
return dvar['out']
return call_utilities.create_numpy_array(numpy.int32())
def reduceat(localization, proxy_obj, arguments):
dvar = call_utilities.parse_varargs_and_kwargs(
localization, arguments, ['axis', 'dtype', 'out'], {
'axis': Integer,
'dtype': type,
'out': numpy.ndarray,
}, 'reduceat', 2)
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 arguments[0]
def negative(localization, proxy_obj, arguments):
dvar = call_utilities.parse_varargs_and_kwargs(
localization, arguments, ['out'], {
'out': numpy.ndarray,
}, 'logical_not')
if isinstance(dvar, StypyTypeError):
return dvar
if Number == type(arguments[0]):
return call_utilities.cast_to_numpy_type(arguments[0])
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 sum(localization, proxy_obj, arguments):
dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments, ['axis', 'dtype', 'out'], {
'axis': [types.NoneType, Integer, IterableDataStructureWithTypedElements(Integer)],
'dtype': type,
'out': numpy.ndarray,
'keepdims': bool}, 'sum')
if isinstance(dvar, StypyTypeError):
return dvar
r = TypeWrapper.get_wrapper_of(proxy_obj.__self__)
if 'out' in dvar.keys():
set_contained_elements_type(localization, dvar['out'],
get_contained_elements_type(localization, r))
return dvar['out']
if 'axis' in dvar.keys():
return call_utilities.create_numpy_array(get_contained_elements_type(localization, r))
return call_utilities.cast_to_numpy_type(get_contained_elements_type(localization, r))
def round_(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, ['decimals', 'out'], {
'decimals': Integer,
'out': numpy.ndarray,
}, 'round_')
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 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 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()
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
r = TypeWrapper.get_wrapper_of(proxy_obj.__self__)
if Number == type(arguments[0]):
c_t = get_contained_elements_type(localization, r)
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]):
if call_utilities.get_dimensions(localization, r) == 1 and call_utilities.get_dimensions(
localization, arguments[0]) == 1:
return call_utilities.cast_to_greater_numpy_type(
call_utilities.get_inner_type(localization, r),
call_utilities.get_inner_type(localization, arguments[0]))
typ = call_utilities.cast_to_greater_numpy_type(call_utilities.get_inner_type(localization, r),
call_utilities.get_inner_type(localization, arguments[0]))
for i in range(call_utilities.get_dimensions(localization, r)):
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 r
def inner(localization, proxy_obj, arguments):
dvar = call_utilities.parse_varargs_and_kwargs(
localization, arguments, ['out'], {
'out': numpy.ndarray,
}, 'inner')
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)
typ = call_utilities.create_numpy_array(DynamicType())
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 iteritems(localization, proxy_obj, arguments):
it = wrap_type(get_sample_instance_for_type("dictionary_itemiterator"))
set_contained_elements_type(localization, it,
arguments[0].get_wrapped_type().items())
return it
