<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def derivative(self, vf):
 """Derivative of the point-wise norm operator at ``vf``. The derivative at ``F`` of the point-wise norm operator ``N`` with finite exponent ``p`` and weights ``w`` is the pointwise inner product with the vector field :: x --> N(F)(x)^(1-p) * [ F_j(x) * |F_j(x)|^(p-2) ]_j Note that this is not well-defined for ``F = 0``. If ``p < 2``, any zero component will result in a singularity. Parameters vf : `domain` `element-like` Vector field ``F`` at which to evaluate the derivative. Returns ------- deriv : `PointwiseInner` Derivative operator at the given point ``vf``. Raises ------ NotImplementedError * if the vector field space is complex, since the derivative is not linear in that case * if the exponent is ``inf`` """

        if self.domain.field == ComplexNumbers():
            raise NotImplementedError('operator not Frechet-differentiable '
                                      'on a complex space')

        if self.exponent == float('inf'):
            raise NotImplementedError('operator not Frechet-differentiable '
                                      'for exponent = inf')

        vf = self.domain.element(vf)
        vf_pwnorm_fac = self(vf)
        if self.exponent != 2:  # optimize away most common case.
            vf_pwnorm_fac **= (self.exponent - 1)

        inner_vf = vf.copy()

        for gi in inner_vf:
            gi *= gi.ufuncs.absolute().ufuncs.power(self.exponent - 2)
            if self.exponent >= 2:
                # Any component that is zero is not divided with
                nz = (vf_pwnorm_fac.asarray() != 0)
                gi[nz] /= vf_pwnorm_fac[nz]
            else:
                # For exponents < 2 there will be a singularity if any
                # component is zero. This results in inf or nan. See the
                # documentation for further details.
                gi /= vf_pwnorm_fac

        return PointwiseInner(self.domain, inner_vf, weighting=self.weights)