def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Boolean:
evaluated_params = []
for idx, param in enumerate(actual_params):
param_value = interpreter.visit(param)
param_type = type(param_value)
if not issubclass(param_type, d.RealNum):
raise err.ArgumentTypeError(
idx=idx,
expected=d.RealNum,
given=param_value
)
evaluated_params.append(param_value)
result = d.Boolean(True)
prev_value = evaluated_params[0]
for param_value in evaluated_params[1:]:
current_value = param_value
if not prev_value >= current_value:
result = d.Boolean(False)
break
prev_value = current_value
return result
def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Boolean:
evaluated_params = []
for idx, param in enumerate(actual_params):
param_value = interpreter.visit(param)
param_type = type(param_value)
if not issubclass(param_type, d.Number):
raise err.ArgumentTypeError(
idx=idx,
expected=d.Number,
given=param_value
)
evaluated_params.append(param_value)
first_param_value = evaluated_params[0]
result = d.Boolean(True)
for param_value in evaluated_params:
if param_value != first_param_value:
result = d.Boolean(False)
break
return result
def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Number:
evaluated_params = []
for idx, param in enumerate(actual_params):
param_value = interpreter.visit(param)
param_type = type(param_value)
if not issubclass(param_type, d.Number):
raise err.ArgumentTypeError(
idx=idx,
expected=d.Number,
given=param_value
)
if param_value == d.Integer(0):
if idx > 0 or (idx == 0 and len(actual_params) == 1):
raise err.BuiltinProcError(
error_code=err.ErrorCode.DIVISION_BY_ZERO,
token=None
)
evaluated_params.append(param_value)
if len(actual_params) == 1:
result = d.Integer(1)/evaluated_params[0]
else:
result = evaluated_params[0]
for param_value in evaluated_params[1:]:
result /= param_value
return result
def _interpret(interpreter: Interpreter,
actual_params: tp.List[ast.AST]) -> d.String:
param_value = interpreter.visit(actual_params[0])
param_type = type(param_value)
if not issubclass(param_type, d.String):
raise err.ArgumentTypeError(expected=d.String, given=param_value)
return param_value.lower()
def _interpret(interpreter: Interpreter,
actual_params: tp.List[ast.AST]) -> d.Boolean:
param_value = interpreter.visit(actual_params[0])
param_type = type(param_value)
if not issubclass(param_type, d.String):
raise err.ArgumentTypeError(expected=d.String, given=param_value)
return d.Boolean(len(param_value) == 0) or param_value.isspace()
def _interpret(interpreter: Interpreter,
actual_params: tp.List[ast.AST]) -> d.List:
param_value = interpreter.visit(actual_params[0])
param_type = type(param_value)
if not issubclass(param_type, d.List):
raise err.ArgumentTypeError(expected=d.List, given=param_value)
result = param_value[::-1]
return result
def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Boolean:
param_value = interpreter.visit(actual_params[0])
param_type = type(param_value)
if not issubclass(param_type, d.Number):
raise err.ArgumentTypeError(
expected=d.Number,
given=param_value
)
result = d.Boolean(param_value == d.Integer(0))
return result
def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Integer:
param_value = interpreter.visit(actual_params[0])
param_type = type(param_value)
if not issubclass(param_type, d.RealNum):
raise err.ArgumentTypeError(
expected=d.RealNum,
given=param_value
)
result = d.Integer(round(param_value.value))
return result
def _interpret(interpreter: Interpreter,
actual_params: tp.List[ast.AST]) -> d.Boolean:
item = interpreter.visit(actual_params[0])
list_ = param_value = interpreter.visit(actual_params[1])
param_type = type(param_value)
if not issubclass(param_type, d.List):
raise err.ArgumentTypeError(expected=d.List, given=param_value)
result = d.Boolean(item in list_)
return result
def _interpret(interpreter: Interpreter,
actual_params: tp.List[ast.AST]) -> d.Boolean:
param_value = interpreter.visit(actual_params[0])
param_type = type(param_value)
if not issubclass(param_type, d.String):
raise err.ArgumentTypeError(expected=d.String, given=param_value)
for char in param_value:
if not char.isalpha():
return d.Boolean(False)
else:
return d.Boolean(True)
def _interpret(interpreter: Interpreter,
actual_params: tp.List[ast.AST]) -> d.List:
count = param_value = interpreter.visit(actual_params[0])
param_type = type(param_value)
if not issubclass(param_type, d.Integer) or param_value < d.Integer(0):
raise err.ArgumentTypeError(expected=d.NaturalNum,
given=param_value)
data = interpreter.visit(actual_params[1])
result = d.List(int(count) * [data])
return result
def _interpret(interpreter: Interpreter,
actual_params: tp.List[ast.AST]) -> d.List:
param_value = interpreter.visit(actual_params[0])
param_type = type(param_value)
if not issubclass(param_type, d.List) or len(param_value) == 0:
raise err.ArgumentTypeError(expected=d.List,
given=param_value,
min_length=1,
max_length=None)
result = param_value[1:]
return result
def _interpret_nth(interpreter: Interpreter, actual_params: tp.List[ast.AST],
idx: int) -> d.Data:
param_value = interpreter.visit(actual_params[0])
param_type = type(param_value)
if not issubclass(param_type, d.List) or len(param_value) <= idx:
raise err.ArgumentTypeError(expected=d.List,
given=param_value,
min_length=idx + 1,
max_length=None)
result = param_value[idx]
return result
def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Number:
param_value = interpreter.visit(actual_params[0])
param_type = type(param_value)
if not issubclass(param_type, d.Number):
raise err.ArgumentTypeError(
expected=d.Number,
given=param_value
)
if param_value < d.Integer(0):
raise NotImplementedError('Complex numbers not supported yet.')
number = math.sqrt(param_value.value)
result = d.InexactNum(number)
return result
def _interpret(interpreter: Interpreter,
actual_params: tp.List[ast.AST]) -> d.Boolean:
result = d.Boolean(True)
for idx, param in enumerate(actual_params):
param_value = interpreter.visit(param)
param_type = type(param_value)
if not issubclass(param_type, d.Boolean):
raise err.ArgumentTypeError(idx=idx,
expected=d.Boolean,
given=param_value)
if param_value == d.Boolean(False):
result = param_value
break
return result
def _interpret(interpreter: Interpreter,
actual_params: tp.List[ast.AST]) -> d.Boolean:
evaluated_params = []
for idx, param in enumerate(actual_params):
param_value = interpreter.visit(param)
param_type = type(param_value)
if not issubclass(param_type, d.String):
raise err.ArgumentTypeError(idx=idx,
expected=d.String,
given=param_value)
evaluated_params.append(param_value)
substring = evaluated_params[0]
containing_string = evaluated_params[1]
result = substring in containing_string
return d.Boolean(result)
def _interpret(interpreter: Interpreter,
actual_params: tp.List[ast.AST]) -> d.List:
evaluated_params = []
for idx, param in enumerate(actual_params):
param_value = interpreter.visit(param)
param_type = type(param_value)
if not issubclass(param_type, d.List):
raise err.ArgumentTypeError(idx=idx,
expected=d.List,
given=param_value)
evaluated_params.append(param_value)
result = d.List([])
for param in evaluated_params:
result.extend(param)
return result
def _interpret(interpreter: Interpreter,
actual_params: tp.List[ast.AST]) -> d.Boolean:
string = param_value = interpreter.visit(actual_params[0])
param_type = type(param_value)
if not issubclass(param_type, d.String):
raise err.ArgumentTypeError(expected=d.String, given=param_value)
index = param_value = interpreter.visit(actual_params[1])
param_type = type(param_value)
if not issubclass(param_type, d.Integer) or index < d.Integer(0):
message = f'string-ith: expected a natural number for the second argument, but received {index}'
raise err.CustomBuiltinProcError(message=message)
if index >= d.Integer(len(string)):
message = f'string-ith: expected an exact integer [0, {len(string)}) '
message += f'(i.e., less than the length of the given string) for the second argument, but received {index}'
raise err.CustomBuiltinProcError(message=message)
return string[index]
def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Integer:
evaluated_params = []
for idx, param in enumerate(actual_params):
param_value = interpreter.visit(param)
param_type = type(param_value)
if not issubclass(param_type, d.Integer):
raise err.ArgumentTypeError(
idx=idx,
expected=d.Integer,
given=param_value
)
evaluated_params.append(param_value)
number = int(evaluated_params[0])
modulus = int(evaluated_params[1])
remainder = number % modulus
result = d.Integer(remainder)
return result
def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.RealNum:
evaluated_params = []
for idx, param in enumerate(actual_params):
param_value = interpreter.visit(param)
param_type = type(param_value)
if not issubclass(param_type, d.RealNum):
raise err.ArgumentTypeError(
idx=idx,
expected=d.RealNum,
given=param_value
)
evaluated_params.append(param_value)
result = evaluated_params[0]
for param_value in evaluated_params[1:]:
if param_value < result:
result = param_value
return result
def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Integer:
evaluated_params = []
for idx, param in enumerate(actual_params):
param_value = interpreter.visit(param)
param_type = type(param_value)
if not issubclass(param_type, d.Integer):
raise err.ArgumentTypeError(
idx=idx,
expected=d.Integer,
given=param_value
)
evaluated_params.append(param_value)
lcm = 1
for param_value in evaluated_params:
lcm = abs(lcm * int(param_value)) // math.gcd(lcm, int(param_value))
result = d.Integer(lcm)
return result
def _interpret(interpreter: Interpreter, actual_params: tp.List[ast.AST]) -> d.Number:
evaluated_params = []
for idx, param in enumerate(actual_params):
param_value = interpreter.visit(param)
param_type = type(param_value)
if not issubclass(param_type, d.Number):
raise err.ArgumentTypeError(
idx=idx,
expected=d.Number,
given=param_value
)
evaluated_params.append(param_value)
result = d.Integer(1)
for param_value in evaluated_params:
if param_value == d.Integer(0):
result = d.Integer(0)
break
result *= param_value
return result
