def listEvaluator(cls, left, operator, right):
if operator.value == "+":
return Type.list(left.value + right.value)
if operator.value == "-":
raise RuntimeException(
f"Operator {operator.value} is not supported by list types",
operator.pos)
raise RuntimeError("This line should never be reached")
def check(args):
if any(
[matcher.optional
for matcher in [varargMatcher, *basicSignature]]):
raise RuntimeError(
"Vararg signature can't have optional arguments")
if len(basicSignature) > len(args):
return doesNotMatchVararg(basicSignature)
for i in range(len(basicSignature)):
if not basicSignature[i].match(args[i]):
return doesNotMatchVararg(basicSignature)
for i in range(len(basicSignature), len(args)):
if not varargMatcher.match(args[i]):
return doesNotMatchVararg(basicSignature)
if wrapVarargInValue:
return True, (*args[:len(basicSignature)]), Type.list(
args[len(basicSignature):])
else:
return True, (
*args[:len(basicSignature)]), args[len(basicSignature):]
def evaluator(cls, node, environment):
iterator = expressionEvaluator(doAssert=True)(node.left,
environment).value
parameters = [identifier.value for identifier in node.parameters
] if type(node.parameters) != NoneNode() else []
try:
environment.appendScope()
output = {
Type.INTEGER: cls.numberEvaluator,
Type.BOOL: cls.boolEvaluator,
Type.LIST: cls.listEvaluator,
Type.MAP: cls.mapEvaluator
}[iterator.type](node, environment, iterator, parameters,
node.filter)
environment.popScope()
except KeyError:
raise RuntimeException(
f"The {iterator.type.name.lower()} type cannot stand as an iterator for loop statement",
node.left.pos)
return Type.list(output)
def evaluator(cls, node, environment):
list = abstractIterableEvaluator(expressionEvaluator(doAssert=True))(node, environment)
return Type.list(list)
def _function(env, signal):
raw = [x.value for x in signal.value]
N = len(raw)
fft = np.fft.fft(raw) / N
fft = fft[range(int(N / 2))]
return Type.list([Type.float(float(abs(x))) for x in fft])
def evaluateForList(cls, value):
return Type.list(value[::-1])
def _function4(env, config, notes):
return Type.list([ Type.float(float(m)) for m in __function4(config, notes) ])
def _function2(env, notes):
return Type.list([Type.float(float(m)) for m in __function2(notes)])
