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): e = self.e.evaluate(env) func: function.FunctionObj = env.find_function('-') new_env = arrange_params_with_function_args([function.Param('e1', e)], func, env) ret = func.compute(new_env) return ret
def create_new_environment(initialized_args: Dict[str, RObj], env: Environment): new_env: Environment = Environment(env) for name, val in initialized_args.items(): val_val = val.evaluate(new_env) new_env.add(name, val_val) return new_env
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): x, y = self.x.evaluate(env), self.y.evaluate(env) func: function.FunctionObj = env.find_function('!') new_env = arrange_params_with_function_args([function.Param('x', x)], func, env) ret = func.compute(new_env) return ret
def evaluate(self, env: Environment): e1, e2 = self.e1.evaluate(env), self.e2.evaluate(env) func: function.FunctionObj = env.find_function('^') ret = func.compute( [function.Param('e1', e1), function.Param('e2', e2)], env) return ret
def compute(self, env: Environment): try: x: RObj = env.find_object_locally('x') except: raise errors.InvalidLeftHandAssignment() try: value: RObj = env.find_object_locally('value') except: raise errors.InvalidLeftHandAssignment() if x.get_type().name == 'symbol': val_value = value.evaluate(env) if val_value.get_type().name == 'call': val_value = val_value.compute(env) env.parent_env.add(x.name, val_value) return val_value raise errors.InvalidLeftHandAssignment()
def compute(self, env: Environment): e1, e2 = self.e1.evaluate(env), self.e2.evaluate(env) func: function.FunctionObj = env.find_function(self.op_name) new_env = arrange_params_with_function_args( [function.Param('e1', e1), function.Param('e2', e2)], func, env) ret = func.compute(new_env) return ret
def arrange_params_with_function_args(params, func, env: Environment): res = func_args_arrange(params, func.input_args) new_env: Environment = Environment(env) for name, val in res.items(): new_env.add(name, val) return new_env
def compute(self, env: Environment): dots: DotsObj = env.find_object('...') items = dots.items list_items = [] for item in items: itm = ListItem(item.name, item.value) list_items.append(itm) return ListObj(list_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') res = VectorItem(None, atomic_or(e1.items[0].value, e2.items[0].value)) ret = VectorObj.create([res]) return ret
def evaluate(self, env: Environment): standart_for_env = env.standart_output env.standart_output = self.standard_output try: for item in self.items: res = execute_item(item, env) self.standard_output(res.show_self()) except CommandException as e: self.standard_output(e.message) except R_RuntimeError as e: self.standard_output(e.message) except RError as e: func = env.find_function('print') try: arrange_params_with_function_args([Param('x', e)], func, env) except Exception as e: self.standard_output(str(e)) finally: env.standart_output = standart_for_env return None
def compute(self, env: Environment): e: DotsObj = env.find_object('...') for index, param in enumerate(e.items): if param[1].get_type().name not in [ 'character', 'double', 'integer', 'logical' ]: raise errors.ArgumentCannotBeHandledByFun( index + 1, param[1].get_type().name, 'cat') for atom in param[1].items: rep = atom.show_self() print(rep) return NULLObj()
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, 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, 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, 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 evaluate(self, env: Environment): fun_to_find = '<-' if isinstance(self.item, DLRObj): fun_to_find = '$<-' elif isinstance(self.item, AssignObj): fun_to_find = '[<-' elif isinstance(self.item, SuperAssignObj): fun_to_find = '[[<-' func: function.FunctionObj = env.find_function( fun_to_find, self.item.get_classes_as_python_list()) new_env = arrange_params_with_function_args([ function.Param('x', self.item), function.Param('value', self.value) ], func, env) ret = func.compute(new_env) return ret
def evaluate(self, env: Environment): x, y = self.x.evaluate(env), self.y.evaluate(env) func: function.FunctionObj = env.find_function('!') ret = func.compute([function.Param('x', x)], env) return ret
def evaluate(self, env: Environment): ret = env.find_object(self.name) return ret
from R.Environment import Environment import R.RObj import R.BuiltIn as builtin from R.Function import FunctionObj, CallObj, Atomic, Arg import R.AtomicObjs as objs import R.Types as types import R.LanguageObjs as language this_env: Environment = Environment(builtin.built_in_env) this_env.set_global(this_env) print('123') items1 = [ language.AssignObj.create(objs.SymbolObj('h'), Atomic.create(1, types.IntegerType())), Atomic.create(2, types.IntegerType()), Atomic.create(5, types.IntegerType()) ] items2 = [ Atomic.create(False, types.LogicalType()), language.AssignObj.create(objs.SymbolObj('f'), Atomic.create(1, types.IntegerType())), Atomic.create(5, types.IntegerType()), language.AssignObj.create(objs.SymbolObj('h'), Atomic.create(1, types.IntegerType())) ] symbol_c = objs.SymbolObj('c') c_call1 = CallObj(symbol_c, items1)
from typing import List from abc import abstractmethod import R.Types as types from R.Environment import Environment from R.Function import FunctionObj, RObj, Arg, DotsObj, Param from R.AtomicObjs import ListItem, ListObj, VectorObj, VectorItem, Atomic, EmptyParamObj, NULLObj import R.RuntimeErrors as errors built_in_env: Environment = Environment(None) class BuiltInFun(FunctionObj): def __init__(self, name, input_args): super(BuiltInFun, self).__init__(input_args, None) self._type = types.BuiltInType() self.name = name @staticmethod @abstractmethod def create(*args): pass @abstractmethod def compute(self, params: List[Param], env: Environment): pass def cast_vector_items(items, python_type, r_type): ret = [VectorItem(item.name, Atomic(python_type(item.value.value), r_type())) for item in items]
def evaluate(self, env: Environment): e = self.e.evaluate(env) func: function.FunctionObj = env.find_function('-') ret = func.compute([function.Param('e1', e)], env) return ret
def evaluate(self, env: Environment): if self.mode == 'super': env = env.global_env if self.item.get_type().name == 'symbol': val_value: RObj = self.value.evaluate(env) name = self.item.name env.add(name, val_value) return val_value elif isinstance(self.item, RObj.get_r_obj('Atomic')): if self.item.get_type().name == "character": name = self.item.value val_value: RObj = self.value.evaluate(env) env.add(name, val_value) return val_value else: raise errors.InvalidLeftHandAssignment() else: val_value: RObj = self.value.evaluate(env) ret = self.item.set_value(val_value, env) return ret # if env == env.global_env: # if self.item.get_type().name == 'symbol': # val_value: RObj = self.init_if_atomic(self.value.evaluate(env)) # name = self.item.name # env.add(name, val_value) # return val_value # elif isinstance(self.item, RObj.get_r_obj('Atomic')): # if self.item.get_type().name == "character": # name = self.item.value # val_value: RObj = self.init_if_atomic(self.value.evaluate(env)) # env.add(name, val_value) # return val_value # else: # raise errors.InvalidLeftHandAssignment() # else: # val_value: RObj = self.init_if_atomic(self.value.evaluate(env)) # ret = self.item.set_value(val_value, env) # return ret # else: # if self.item.get_type().name == 'symbol': # val_value: RObj = self.init_if_atomic(self.value.evaluate(env)) # name = self.item.name # env.add(name, val_value) # env.global_env.add(name, val_value) # return val_value # elif isinstance(self.item, RObj.get_r_obj('Atomic')): # if self.item.get_type().name == "character": # name = self.item.value # val_value: RObj = self.init_if_atomic(self.value.evaluate(env)) # env.add(name, val_value) # env.global_env.add(name, val_value) # return val_value # else: # raise errors.InvalidLeftHandAssignment() # else: # raise errors.InvalidLeftHandAssignment() else: if self.item.get_type().name == 'symbol': val_value: RObj = self.value.evaluate(env) name = self.item.name env.add(name, val_value) return val_value elif isinstance(self.item, RObj.get_r_obj('Atomic')): if self.item.get_type().name == "character": name = self.item.value val_value: RObj = self.value.evaluate(env) env.add(name, val_value) return val_value else: raise errors.InvalidLeftHandAssignment() else: val_value: RObj = self.value.evaluate(env) ret = self.item.set_value(val_value, env) return ret
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