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 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 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 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 interp(localization, proxy_obj, arguments):
dvar = call_utilities.parse_varargs_and_kwargs(
localization, arguments, ['xp', 'fp', 'left', 'right', 'period'], {
'xp': IterableDataStructureWithTypedElements(RealNumber),
'fp': IterableDataStructureWithTypedElements(Number),
'left': Number,
'right': Number,
'period': RealNumber,
}, 'interp')
if isinstance(dvar, StypyTypeError):
return dvar
if Number == type(arguments[0]):
return arguments[0]
return call_utilities.create_numpy_array(numpy.float64())
def argpartition(localization, proxy_obj, arguments):
dvar = call_utilities.parse_varargs_and_kwargs(
localization, arguments, ['kth', 'axis', 'kind', 'order'], {
'kth':
[Integer,
IterableDataStructureWithTypedElements(Integer)],
'axis': Integer,
'kind': Str,
'order': [Str,
IterableDataStructureWithTypedElements(Str)]
}, 'argpartition')
if isinstance(dvar, StypyTypeError):
return dvar
if Number == type(arguments[0]):
return call_utilities.create_numpy_array(arguments[0])
if call_utilities.is_numpy_array(arguments[0]):
return arguments[0]
return call_utilities.create_numpy_array(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 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 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 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 as_strided(localization, proxy_obj, arguments):
dvar = call_utilities.parse_varargs_and_kwargs(
localization, arguments,
['shape', 'strides', 'subok', 'writeable'], {
'shape': IterableDataStructureWithTypedElements(Integer),
'strides': IterableDataStructureWithTypedElements(Integer),
'subok': bool,
'writeable': bool,
}, 'as_strided')
if isinstance(dvar, StypyTypeError):
return dvar
if 'shape' in dvar.keys():
shape = dvar['shape'].get_wrapped_type()
else:
shape = None
if 'strides' in dvar.keys():
strides = dvar['strides'].get_wrapped_type()
else:
strides = None
import numpy.lib.stride_tricks as st
return st.as_strided(arguments[0], shape, strides)
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 repeat(localization, proxy_obj, arguments):
dvar = call_utilities.parse_varargs_and_kwargs(localization, arguments,
['repeats', 'axis'], {
'repeats': [Integer,
IterableDataStructureWithTypedElements(Integer)],
'axis': Integer,
}, 'repeat')
if isinstance(dvar, StypyTypeError):
return dvar
r = TypeWrapper.get_wrapper_of(proxy_obj.__self__)
if 'axis' in dvar.keys():
return r
else:
typ = call_utilities.get_inner_type(localization, r)
return call_utilities.create_numpy_array(typ)
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 argsort(localization, proxy_obj, arguments, fname='argsort'):
dvar = call_utilities.parse_varargs_and_kwargs(
localization, arguments, ['axis', 'kind', 'order'], {
'axis': Integer,
'kind': Str,
'order': [Str,
IterableDataStructureWithTypedElements(Str)]
}, fname)
if isinstance(dvar, StypyTypeError):
return dvar
t = call_utilities.check_possible_values(
dvar, 'kind', ['quicksort', 'mergesort', 'heapsort'])
if isinstance(t, StypyTypeError):
return t
if Number == type(arguments[0]):
return call_utilities.create_numpy_array(arguments[0])
if call_utilities.is_numpy_array(arguments[0]):
return arguments[0]
return call_utilities.create_numpy_array(arguments[0])
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]
def genfromtxt(localization, proxy_obj, arguments):
dvar = call_utilities.parse_varargs_and_kwargs(
localization, arguments, [
'fname', 'dtype', 'comments', 'delimiter', 'skiprows',
'skip_header', 'skip_footer', 'converters', 'missing_values',
'filling_values', 'usecols', 'names', 'excludelist',
'deletechars', 'defaultfmt', 'autostrip', 'replace_space',
'case_sensitive', 'unpack', 'usemask', 'loose',
'invalid_raise', 'max_rows'
], {
'fname':
[file, Str,
IterableDataStructureWithTypedElements(Str)],
'dtype':
type,
'comments':
Str,
'delimiter': [Str, Integer],
'skiprows':
Integer,
'skip_header':
Integer,
'skip_footer':
Integer,
'converters':
IterableDataStructureWithTypedElements(types.LambdaType),
'missing_values':
IterableDataStructureWithTypedElements(Str),
'filling_values':
IterableDataStructure,
'usecols':
IterableDataStructureWithTypedElements(Integer),
'names':
[bool, Str,
IterableDataStructureWithTypedElements(Str)],
'excludelist':
IterableDataStructureWithTypedElements(Str),
'deletechars':
Str,
'defaultfmt':
Str,
'autostrip':
bool,
'replace_space':
Str,
'case_sensitive': [bool, Str],
'unpack':
bool,
'usemask':
bool,
'loose':
bool,
'invalid_raise':
bool,
'max_rows':
Integer,
}, 'genfromtxt', 0)
if isinstance(dvar, StypyTypeError):
return dvar
if 'case_sensitive' in dvar.keys():
if Str == type(dvar['case_sensitive']):
temp = call_utilities.check_possible_values(
dvar, 'case_sensitive', ['upper', 'lower'])
if isinstance(temp, StypyTypeError):
return temp
return call_utilities.create_numpy_array(DynamicType())