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 visit_Rat(self, node: ast.Rat) -> Union[d.Integer, d.RationalNum]:
numerator = node.value[0]
denominator = node.value[1]
fraction = f.Fraction(numerator, denominator)
if fraction.denominator == 1:
return d.Integer(fraction.numerator)
else:
return d.RationalNum(fraction.numerator, fraction.denominator)
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
)
if param_value > d.Integer(0):
result = d.Integer(1)
elif param_value < d.Integer(0):
result = d.Integer(-1)
else:
result = d.Integer(0)
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.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.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.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
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.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.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:
result = d.Integer(math.floor(time.time()))
return result
def visit_Int(self, node: ast.Int) -> d.Integer:
return d.Integer(node.value)