def compute(self, env: Environment):
e1 = env.find_object('e1')
e2 = env.find_object('e2')
if e1.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('x', 'x ** y')
if e2.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('y', 'x ** y')
as_integer = False
if e1.get_type().name == 'integer' and e2.get_type().name == 'integer':
as_integer = True
elif e1.get_type().name == 'integer' and e2.get_type(
).name == 'logical':
as_integer = True
elif e1.get_type().name == 'logical' and e2.get_type(
).name == 'integer':
as_integer = True
res = perform_op_on_vector_or_atomic(
e1, e2,
lambda l, r: cast_atomic(atomic_mod(l, r), 'integer'
if as_integer else 'double'))
res = [VectorItem(None, el) for el in res]
if len(res) == 0:
t = get_more_important_vector_type(e1.get_type(), e2.get_type())
return VectorObj([], t)
ret = VectorObj.create(res)
return ret
def compute(self, env: Environment):
e1 = env.find_object('e1')
e2 = env.find_object('e2')
if isinstance(e2, EmptyParamObj):
if e1.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('x', '- x')
res = []
for item in e1.items:
res.append(
atomic_subtract(Atomic(False, types.LogicalType()),
item.value))
res = [VectorItem(None, el) for el in res]
ret = VectorObj(res)
return ret
if e1.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('x', 'x - y')
if e2.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('y', 'x - y')
as_integer = False
if e1.get_type().name == 'integer' and e2.get_type().name == 'integer':
as_integer = True
elif e1.get_type().name == 'integer' and e2.get_type(
).name == 'logical':
as_integer = True
elif e1.get_type().name == 'logical' and e2.get_type(
).name == 'integer':
as_integer = True
res = perform_op_on_vector_or_atomic(
e1, e2,
lambda l, r: cast_atomic(atomic_subtract(l, r), 'integer'
if as_integer else 'double'))
res = [VectorItem(None, el) for el in res]
if len(res) == 0:
t = get_more_important_vector_type(e1.get_type(), e2.get_type())
return VectorObj([], t)
ret = VectorObj.create(res)
return ret
def compute(self, params: List[Param], env: Environment):
args = self.arrange_args(params)
e1: Param = args['e1']
e2: Param = args['e2']
if e1.value.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('x', 'x ** y')
if e2.value.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('y', 'x ** y')
res = []
as_integer = False
if e1.value.get_type().name == 'integer' and e2.value.get_type().name == 'integer':
as_integer = True
elif e1.value.get_type().name == 'integer' and e2.value.get_type().name == 'logical':
as_integer = True
elif e1.value.get_type().name == 'logical' and e2.value.get_type().name == 'integer':
as_integer = True
for l, r in concat_vectors(e1.value.items, e2.value.items):
res.append(cast_atomic(atomic_mod(l.value, r.value), 'integer' if as_integer else 'double'))
res = [VectorItem(None, el) for el in res]
ret = VectorObj(res)
return ret
def compute(self, env: Environment):
ln: VectorObj = env.find_object('length')
if ln.get_type().name not in ['double', 'integer']:
raise errors.InvalidArg('length')
if len(ln.items) != 1:
raise errors.InvalidArg('length')
val = ln.items[0][1]
if val.is_inf:
raise errors.R_RuntimeError('vector size cannot be infinite')
elif val.is_na:
raise errors.InvalidArg('length')
elif val.is_nan:
raise errors.R_RuntimeError('vector size cannot be NA/NaN')
count = val.value
items = [
VectorItem(None, Atomic(False, types.LogicalType()))
for _ in range(int(count) * (-1 if val.is_neg else 1))
]
ret = VectorObj(items, types.LogicalType())
return ret
def compute(self, env: Environment):
e1 = env.find_object('x')
if e1.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgType()
res = []
if isinstance(e1, VectorObj):
if len(e1.items) == 0:
return VectorObj([], type(e1.get_type())())
for item in e1.items:
res.append(atomic_not(item[1]))
else:
res.append(atomic_not(e1))
res = [VectorItem(None, el) for el in res]
ret = VectorObj.create(res)
return ret
def compute(self, env: Environment):
e1 = env.find_object('x')
e2 = env.find_object('y')
if e1.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('x', 'x | y')
if e2.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('y', 'x | y')
res = VectorItem(None, atomic_or(e1.items[0].value, e2.items[0].value))
ret = VectorObj.create([res])
return ret
def compute(self, params: List[Param], env: Environment):
args = self.arrange_args(params)
e1: Param = args['x']
e2: Param = args['y']
if e1.value.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('x', 'x | y')
if e2.value.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('y', 'x | y')
res = VectorItem(None, atomic_or(e1.value.items[0].value, e2.value.items[0].value))
ret = VectorObj([res])
return ret
def compute(self, params: List[Param], env: Environment):
args = self.arrange_args(params)
e1: Param = args['x']
if e1.value.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgType()
res = []
for item in e1.value.items:
res.append(atomic_not(item.value))
res = [VectorItem(None, el) for el in res]
ret = VectorObj(res)
return ret
def compute(self, env: Environment):
e1 = env.find_object('x')
e2 = env.find_object('y')
if e1.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('x', 'x || y')
if e2.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('y', 'x || y')
res = perform_op_on_vector_or_atomic(
e1, e2, lambda l, r: cast_atomic(atomic_power(l, r)))
res = [VectorItem(None, el) for el in res]
ret = VectorObj.create(res)
return ret
def compute(self, params: List[Param], env: Environment):
args = self.arrange_args(params)
e1: Param = args['x']
e2: Param = args['y']
if e1.value.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('x', 'x || y')
if e2.value.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('y', 'x || y')
res = []
for l, r in concat_vectors(e1.value.items, e2.value.items):
res.append(atomic_or(l.value, r.value))
res = [VectorItem(None, el) for el in res]
ret = VectorObj(res)
return ret
def compute(self, env: Environment):
dots: DotsObj = env.find_object('...')
if dots.get_type().name == 'NULL':
return NULLObj()
items = dots.items
if len(items) == 0:
return NULLObj()
items_types = set(map(lambda i: i[1].get_type().name, items))
casts = ['list', 'character', 'double', 'integer', 'logical']
if set(casts).issubset(items_types):
list_fun: FunctionObj = built_in_env.find_function('list')
ret = list_fun.compute(env)
return ret
flat_items = []
for item in items:
if isinstance(item[1], Atomic):
flat_items.append(VectorItem(item[0], item[1]))
elif isinstance(item[1], VectorObj):
flat_items.extend(item[1].items)
else:
raise Exception('Invalid item in c function - {}'.format(item))
if 'character' in items_types:
if len(items_types) > 1:
flat_items = cast_vector_items(flat_items, str,
types.CharacterType)
elif 'double' in items_types:
if len(items_types) > 1:
flat_items = cast_vector_items(flat_items, float,
types.DoubleType)
elif 'integer' in items_types:
if len(items_types) > 1:
flat_items = cast_vector_items(flat_items, int,
types.IntegerType)
elif 'logical' in items_types:
if len(items_types) > 1:
flat_items = cast_vector_items(flat_items, bool,
types.LogicalType)
else:
raise Exception(
"unknown vector type in types - {}".format(items_types))
return VectorObj.create(flat_items)
def compute(self, env: Environment):
e1 = env.find_object('x')
e2 = env.find_object('y')
if e1.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('x', 'x && y')
if e2.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('y', 'x && y')
try:
res = perform_op_on_vector_or_atomic(e1, e2, atomic_and)
except UnsupportedVectorType as e:
raise errors.InvalidArgTypeInArgs(
'x' if e.operand_index == 0 else 'y', 'x && y')
res = [VectorItem(None, el) for el in res]
ret = VectorObj.create(res)
return ret
def compute(self, env: Environment):
if self.base_obj.get_type().name == 'symbol':
fun: FunctionObj = env.find_function(self.base_obj.name)
else:
fun: FunctionObj = self.base_obj.evaluate(env)
if not isinstance(fun, FunctionObj):
raise errors.ApplyToNonFunction()
args = []
assg_obj = RObj.get_r_obj('AssignObj')
for item in self.items:
# item_val = item.evaluate(env)
if isinstance(item, DotsObj):
args.extend(item.items)
elif isinstance(item, Atomic):
n = VectorObj.create([VectorItem(None, item)])
args.append(Param(None, n))
elif isinstance(item, assg_obj):
if item.mode == 'plain':
if item.item.get_type().name == 'symbol':
name = item.item.name
elif isinstance(item.item, Atomic):
if item.item.get_type().name == 'character':
name = item.item[0]
else:
raise errors.InvalidLeftHandAssignment()
else:
raise errors.InvalidLeftHandAssignment()
arg = Param(name, item.value.evaluate(env))
args.append(arg)
else:
arg = Param(None, item.evaluate(env))
args.append(arg)
else:
arg = Param(None, item.evaluate(env))
args.append(arg)
try:
ret = fun.compute(args, env)
except errors.R_RuntimeError as e:
r = RError(self, e.message)
if not self.exception_occurred(r):
raise r
return ret
def compute(self, params: List[Param], env: Environment):
args = self.arrange_args(params)
e1: Param = args['x']
e2: Param = args['y']
if e1.value.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('x', 'x && y')
if e2.value.get_type().name not in ['double', 'logical', 'integer']:
raise errors.InvalidArgTypeInArgs('y', 'x && y')
res = []
try:
for l, r in concat_vectors(e1.value.items, e2.value.items):
res.append(atomic_and(l.value, r.value))
except UnsupportedVectorType as e:
raise errors.InvalidArgTypeInArgs('x' if e.operand_index == 0 else 'y', 'x && y')
res = [VectorItem(None, el) for el in res]
ret = VectorObj(res)
return ret
def compute(self, params: List[Param], env: Environment):
args = self.arrange_args(params)
dots: DotsObj = args['...']
items = dots.items
if len(items) == 0:
return RObj.get_r_obj('NULLObj').create()
items_types = set(map(lambda i: i.value.get_type().name, items))
casts = ['list', 'character', 'double', 'integer', 'logical']
if set(casts).issubset(items_types):
list_fun: FunctionObj = built_in_env.find_function('list')
ret = list_fun.compute(params, env)
return ret
flat_items = []
for item in items:
if isinstance(item.value, Atomic):
flat_items.append(VectorItem(item.name, item.value))
elif isinstance(item.value, VectorObj):
flat_items.extend(item.value.items)
else:
raise Exception('Invalid item in c function - {}'.format(item))
if 'character' in items_types:
if len(items_types) > 1:
flat_items = cast_vector_items(flat_items, str, types.CharacterType)
elif 'double' in items_types:
if len(items_types) > 1:
flat_items = cast_vector_items(flat_items, float, types.DoubleType)
elif 'integer' in items_types:
if len(items_types) > 1:
flat_items = cast_vector_items(flat_items, int, types.IntegerType)
elif 'logical' in items_types:
if len(items_types) > 1:
flat_items = cast_vector_items(flat_items, bool, types.LogicalType)
else:
raise Exception("unknown vector type in types - {}".format(items_types))
return VectorObj.create(flat_items)
def evaluate(self, env: Environment):
if self.as_from_lang:
try:
return self.base_obj.compute(env)
except errors.R_RuntimeError as e:
r = RError.create_simple(self, e.message)
if not self.exception_occurred(r):
raise r
if self.base_obj.get_type().name == 'symbol':
fun: FunctionObj = env.find_function(self.base_obj.name)
if not isinstance(fun, FunctionObj):
raise RError.create_simple(self,
errors.ApplyToNonFunction().message)
else:
fun: FunctionObj = self.base_obj.evaluate(env)
if not isinstance(fun, FunctionObj):
raise errors.ApplyToNonFunction()
args = []
assg_obj = RObj.get_r_obj('AssignObj')
for item in self.items:
if isinstance(item, DotsObj):
args.extend(item.items)
elif isinstance(item, Atomic):
n = VectorObj.create([VectorItem(None, item)])
args.append(Param(None, n))
elif isinstance(item, assg_obj):
if item.item.get_type().name == 'symbol':
name = item.item.name
elif isinstance(item.item, Atomic):
if item.item.get_type().name == 'character':
name = item.item[0]
else:
raise RError.create_simple(
self,
errors.InvalidLeftHandAssignment().message)
else:
raise RError.create_simple(
self,
errors.InvalidLeftHandAssignment().message)
arg = Param(name, item.value.evaluate(env))
args.append(arg)
else:
arg = Param(None, item.evaluate(env))
args.append(arg)
# if item.mode == 'plain':
# if item.item.get_type().name == 'symbol':
# name = item.item.name
# elif isinstance(item.item, Atomic):
# if item.item.get_type().name == 'character':
# name = item.item[0]
# else:
# raise errors.InvalidLeftHandAssignment()
# else:
# raise errors.InvalidLeftHandAssignment()
# arg = Param(name, item.value.evaluate(env))
# args.append(arg)
# else:
# arg = Param(None, item.evaluate(env))
# args.append(arg)
# else:
# arg = Param(None, item.evaluate(env))
# args.append(arg)
try:
res = func_args_arrange(args, fun.input_args)
new_env: Environment = Environment(env)
for name, val in res.items():
new_env.add(name, val)
ret = fun.compute(new_env)
return ret
except errors.R_RuntimeError as e:
r = RError.create_simple(self, e.message)
if not self.exception_occurred(r):
raise r
