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 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 __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 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(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 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 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 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 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 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 rand(localization, proxy_obj, arguments):
for i in range(len(arguments)):
if not (Integer == type(arguments[i])):
return StypyTypeError(localization, "Non-integer argument passed to rand function")
dims = len(arguments)
return call_utilities.create_numpy_array_n_dimensions(numpy.float64(), 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 __getitem__(localization, proxy_obj, arguments):
if isinstance(arguments[0], tuple):
num = len(arguments[0])
typ = call_utilities.cast_to_numpy_type(arguments[0][0].get_wrapped_type().start)
union = None
for i in range(num):
union = union_type.UnionType.add(union, call_utilities.create_numpy_array_n_dimensions(typ, num))
tup = call_utilities.wrap_contained_type((union,))
tup.set_contained_type(union)
return tup
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 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 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()