code: def adjoint(self):
          
          if not self.is_linear:
              raise NotImplementedError('this operator is not linear and '
                                        'thus has no adjoint')
  
          forward_op = self
  
          class ResizingOperatorAdjoint(ResizingOperatorBase):
  
              """Adjoint of `ResizingOperator`.
  
              See `the online documentation
              <https://odlgroup.github.io/odl/math/resizing_ops.html>`_
              on resizing operators for mathematical details.
              """
  
              def _call(self, x, out):
                  """Implement ``self(x, out)``."""
                  with writable_array(out) as out_arr:
                      resize_array(x.asarray(), self.range.shape,
                                   offset=self.offset, pad_mode=self.pad_mode,
                                   pad_const=0, direction='adjoint',
                                   out=out_arr)
  
              @property
              def adjoint(self):
                  """Adjoint of the adjoint, i.e. the original operator."""
                  return forward_op
  
              @property
              def inverse(self):
                  """(Pseudo-)Inverse of this operator.
  
                  Note that in axes where ``self`` extends, the returned operator
                  acts as a proper inverse, while in restriction axes, the
                  operation is not invertible.
                  """
                  return ResizingOperatorAdjoint(
                      domain=self.range, range=self.domain,
                      pad_mode=self.pad_mode)
  
          return ResizingOperatorAdjoint(domain=self.range, range=self.domain,
                                         pad_mode=self.pad_mode)
docs: Adjoint of this operator.