code: def derivative(self, vf):
          
          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)
docs: 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``