def METHOD_NAME(self, node, options=None):
    '''Apply the ABS intrinsic conversion transformation to the specified
    node. This node must be an ABS UnaryOperation. The ABS
    UnaryOperation is converted to equivalent inline code. This is
    implemented as a PSyIR transform from:
    .. code-block:: python
        R = ... ABS(X) ...
    to:
    .. code-block:: python
        tmp_abs = X
        if tmp_abs < 0.0:
            res_abs = tmp_abs*-1.0
        else:
            res_abs = tmp_abs
        R = ... res_abs ...
    where ``X`` could be an arbitrarily complex PSyIR expression
    and ``...`` could be arbitrary PSyIR code.
    This transformation requires the operation node to be a
    descendent of an assignment and will raise an exception if
    this is not the case.
    :param node: an ABS UnaryOperation node.
    :type node: :py:class:`psyclone.psyir.nodes.UnaryOperation`
    :param options: a dictionary with options for transformations.
    :type options: Optional[Dict[str, Any]]
    '''
    # pylint: disable=too-many-locals
    self.validate(node)
    symbol_table = node.scope.symbol_table
    assignment = node.ancestor(Assignment)
    # Create two temporary variables.  There is an assumption here
    # that the ABS Operator returns a PSyIR real type. This might
    # not be what is wanted (e.g. the args might PSyIR integers),
    # or there may be errors (arguments are of different types)
    # but this can't be checked as we don't have the appropriate
    # methods to query nodes (see #658).
    symbol_res_var = symbol_table.new_symbol(
        "res_abs", symbol_type=DataSymbol, datatype=REAL_TYPE)
    symbol_tmp_var = symbol_table.new_symbol(
        "tmp_abs", symbol_type=DataSymbol, datatype=REAL_TYPE)
    # Replace operation with a temporary (res_X).
    node.replace_with(Reference(symbol_res_var))
    # tmp_var=X
    lhs = Reference(symbol_tmp_var)
    rhs = node.children[0].detach()
    new_assignment = Assignment.create(lhs, rhs)
    assignment.parent.children.insert(assignment.position, new_assignment)
    # if condition: tmp_var>0.0
    lhs = Reference(symbol_tmp_var)
    rhs = Literal("0.0", REAL_TYPE)
    if_condition = BinaryOperation.create(BinaryOperation.Operator.GT,
                                          lhs, rhs)
    # then_body: res_var=tmp_var
    lhs = Reference(symbol_res_var)
    rhs = Reference(symbol_tmp_var)
    then_body = [Assignment.create(lhs, rhs)]
    # else_body: res_var=-1.0*tmp_var
    lhs = Reference(symbol_res_var)
    lhs_child = Reference(symbol_tmp_var)
    rhs_child = Literal("-1.0", REAL_TYPE)
    rhs = BinaryOperation.create(BinaryOperation.Operator.MUL, lhs_child,
                                 rhs_child)
    else_body = [Assignment.create(lhs, rhs)]
    # if [if_condition] then [then_body] else [else_body]
    if_stmt = IfBlock.create(if_condition, then_body, else_body)
    assignment.parent.children.insert(assignment.position, if_stmt)