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('', types.CharacterType()))
for _ in range(int(count) * (-1 if val.is_neg else 1))
]
ret = VectorObj(items, types.CharacterType())
return ret
def create_simple(call, description):
l: RObj = RObj.get_r_obj('ListObj')\
.create([ListItem('call', call),
ListItem('message', RObj.get_r_obj('Atomic').create(description, types.CharacterType()))])
l.set_attr(
'class',
RObj.get_r_obj('Atomic').create('simpleError',
types.CharacterType()))
return l
def get_default_class(self):
if self.get_type().name == 'character':
ret = 'character'
elif self.get_type().name == 'double':
ret = 'numeric'
elif self.get_type().name == 'integer':
ret = 'integer'
elif self.get_type().name == 'logical':
ret = 'logical'
else:
raise Exception('vector was initialized with improper type - {}'.format(self.get_type().name))
return RObj.get_r_obj('Atomic')(ret, types.CharacterType())
def get_more_important_vector_type(type1, type2):
tps = [type1.name, type2.name]
# if 'list' in tps:
# return types.ListType()
if 'character' in tps:
return types.CharacterType()
elif 'double' in tps:
return types.DoubleType()
elif 'integer' in tps:
return types.IntegerType()
elif 'logical' in tps:
return types.LogicalType()
first = tps[0] not in ['character', 'double', 'integer', 'logical']
raise UnsupportedVectorType(tps, operand_index=0 if first else 1)
def cast_atomic(e: Atomic, type_name):
if e.get_type().name == type_name:
return e
elif type_name == 'character':
ret = Atomic(bool(e.value), types.CharacterType(), is_na=e.is_na, is_nan=e.is_nan, is_inf=e.is_inf,
is_neg=e.is_neg)
return ret
elif type_name == 'double':
ret = Atomic(float(e.value), types.DoubleType(), is_na=e.is_na, is_nan=e.is_nan, is_inf=e.is_inf,
is_neg=e.is_neg)
return ret
elif type_name == 'integer':
ret = Atomic(int(e.value), types.IntegerType(), is_na=e.is_na, is_nan=e.is_nan, is_inf=e.is_inf,
is_neg=e.is_neg)
return ret
elif type_name == 'logical':
ret = Atomic(bool(e.value), types.LogicalType(), is_na=e.is_na, is_nan=e.is_nan, is_inf=e.is_inf,
is_neg=e.is_neg)
return ret
else:
raise Exception('unsupported vector cast type - {}'.format(type_name))
def evaluate(self):
return language.Atomic.create(self.value, types.CharacterType())
def get_default_class(self):
return RObj.get_r_obj('Atomic')('function', types.CharacterType())
def get_default_class(self):
val_op = '='
return RObj.get_r_obj('Atomic')(val_op, types.CharacterType())
