How to use the numexpr.expressions.ConstantNode function in numexpr

def operation(self, other):
        if reversed:
            self, other = other, self
        if allConstantNodes([self, other]):
            return ConstantNode(opfunc(self.value, other.value))
        else:
            return OpNode(opname, (self, other), kind=kind)

def __neg__(self):
        return ConstantNode(-self.value)

def __invert__(self):
        return ConstantNode(~self.value)

def _func(a, axis=None):
        axis = encode_axis(axis)
        if isinstance(a, ConstantNode):
            return a
        if isinstance(a, (bool, int_, long_, float, double, complex)):
            a = ConstantNode(a)
        return FuncNode(name, [a, axis], kind=a.astKind)
    return _func

def truediv_op(a, b):
    if get_optimization() in ('moderate', 'aggressive'):
        if (isinstance(b, ConstantNode) and
                (a.astKind == b.astKind) and
                    a.astKind in ('float', 'double', 'complex')):
            return OpNode('mul', [a, ConstantNode(1. / b.value)])
    kind = commonKind([a, b])
    if kind in ('bool', 'int', 'long'):
        kind = 'double'
    return OpNode('div', [a, b], kind=kind)

def pow_op(a, b):
    if (_np_version_forbids_neg_powint and
        b.astKind in ('int', 'long') and
        a.astKind in ('int', 'long') and
        numpy.any(b.value < 0)):

        raise ValueError(
            'Integers to negative integer powers are not allowed.')

    if allConstantNodes([a, b]):
        return ConstantNode(a.value ** b.value)
    if isinstance(b, ConstantNode):
        x = b.value
        if get_optimization() == 'aggressive':
            RANGE = 50  # Approximate break even point with pow(x,y)
            # Optimize all integral and half integral powers in [-RANGE, RANGE]
            # Note: for complex numbers RANGE could be larger.
            if (int(2 * x) == 2 * x) and (-RANGE <= abs(x) <= RANGE):
                n = int_(abs(x))
                ishalfpower = int_(abs(2 * x)) % 2

                def multiply(x, y):
                    if x is None: return y
                    return OpNode('mul', [x, y])

                r = None
                p = a

def where_func(a, b, c):
    if isinstance(a, ConstantNode):
        return b if a.value else c
    if allConstantNodes([a, b, c]):
        return ConstantNode(numpy.where(a, b, c))
    return FuncNode('where', [a, b, c])