def replace_rhs_variable(cls, expr: ASTExpression,
variable_name_to_replace: str,
kernel_var: ASTVariable, spike_buf: ASTInputPort):
"""
Replace variable names in definitions of kernel dynamics
:param expr: expression in which to replace the variables
:param variable_name_to_replace: variable name to replace in the expression
:param kernel_var: kernel variable instance
:param spike_buf: input port instance
:return:
"""
def replace_kernel_var(node):
if type(node) is ASTSimpleExpression \
and node.is_variable() \
and node.get_variable().get_name() == variable_name_to_replace:
var_order = node.get_variable().get_differential_order()
new_variable_name = cls.construct_kernel_X_spike_buf_name(
kernel_var.get_name(),
spike_buf,
var_order - 1,
diff_order_symbol="'")
new_variable = ASTVariable(new_variable_name, var_order)
new_variable.set_source_position(
node.get_variable().get_source_position())
node.set_variable(new_variable)
expr.accept(ASTHigherOrderVisitor(visit_funcs=replace_kernel_var))
def create_ast_expression(cls, is_encapsulated=False, unary_operator=None,
is_logical_not=False, expression=None, source_position=None):
# type: (bool,ASTUnaryOperator,bool,ASTExpression|ASTSimpleExpression,ASTSourceLocation) -> ASTExpression
"""
The factory method used to create rhs which are either encapsulated in parentheses (e.g., (10mV))
OR have a unary (e.g., ~bitVar), OR are negated (e.g., not logVar), or are simple rhs (e.g., 10mV).
"""
return ASTExpression(is_encapsulated=is_encapsulated, unary_operator=unary_operator,
is_logical_not=is_logical_not, expression=expression, source_position=source_position)
def create_ast_ternary_expression(cls,
condition, # type: Union(ASTSimpleExpression,ASTExpression)
if_true, # type: Union(ASTSimpleExpression,ASTExpression)
if_not, # type: Union(ASTSimpleExpression,ASTExpression)
source_position # type: ASTSourceLocation
): # type: (...) -> ASTExpression
"""
The factory method used to create a ternary operator rhs, e.g., 10mV<V_m?10mV:V_m
"""
return ASTExpression(condition=condition, if_true=if_true, if_not=if_not, source_position=source_position)
def create_ast_compound_expression(cls,
lhs, # type: Union(ASTExpression,ASTSimpleExpression)
binary_operator,
# type: Union(ASTLogicalOperator,ASTBitOperator,ASTComparisonOperator,ASTArithmeticOperator)
rhs, # type: Union(ASTExpression,ASTSimpleExpression)
source_position # type: ASTSourceLocation
): # type: (...) -> ASTExpression
"""
The factory method used to create compound expressions, e.g. 10mV + V_m.
"""
assert (binary_operator is not None and (isinstance(binary_operator, ASTBitOperator)
or isinstance(binary_operator, ASTComparisonOperator)
or isinstance(binary_operator, ASTLogicalOperator)
or isinstance(binary_operator, ASTArithmeticOperator))), \
'(PyNestML.AST.Expression) No or wrong type of binary operator provided (%s)!' % type(binary_operator)
return ASTExpression(lhs=lhs, binary_operator=binary_operator, rhs=rhs, source_position=source_position)
