code: def _call_numpy(self, x):
          
          # Pre-processing before calculating the DFT
          # Note: since the FFT call is out-of-place, it does not matter if
          # preprocess produces real or complex output in the R2C variant.
          # There is no significant time difference between (full) R2C and
          # C2C DFT in Numpy.
          preproc = self._preprocess(x)
  
          # The actual call to the FFT library, out-of-place unfortunately
          if self.halfcomplex:
              out = np.fft.rfftn(preproc, axes=self.axes)
          else:
              if self.sign == '-':
                  out = np.fft.fftn(preproc, axes=self.axes)
              else:
                  out = np.fft.ifftn(preproc, axes=self.axes)
                  # Numpy's FFT normalizes by 1 / prod(shape[axes]), we
                  # need to undo that
                  out *= np.prod(np.take(self.domain.shape, self.axes))
  
          # Post-processing accounting for shift, scaling and interpolation
          self._postprocess(out, out=out)
          return out
docs: Return ``self(x)`` for numpy back-end.
  
          Parameters
          ----------
          x : `numpy.ndarray`
              Array representing the function to be transformed
  
          Returns
          -------
          out : `numpy.ndarray`
              Result of the transform