class_docstr: Sparse matrix with DIAgonal storage
  
  This can be instantiated in several ways:
      dia_matrix(D)
          with a dense matrix
  
      dia_matrix(S)
          with another sparse matrix S (equivalent to S.todia())
  
      dia_matrix((M, N), [dtype])
          to construct an empty matrix with shape (M, N),
          dtype is optional, defaulting to dtype='d'.
  
      dia_matrix((data, offsets), shape=(M, N))
          where the ``data[k,:]`` stores the diagonal entries for
          diagonal ``offsets[k]`` (See example below)
  
  Attributes
  ----------
  dtype : dtype
      Data type of the matrix
  shape : 2-tuple
      Shape of the matrix
  ndim : int
      Number of dimensions (this is always 2)
  nnz
      Number of stored values, including explicit zeros
  data
      DIA format data array of the matrix
  offsets
      DIA format offset array of the matrix
  
  Notes
  -----
  
  Sparse matrices can be used in arithmetic operations: they support
  addition, subtraction, multiplication, division, and matrix power.
  
  Examples
  --------
  
  >>> import numpy as np
  >>> from scipy.sparse import dia_matrix
  >>> dia_matrix((3, 4), dtype=np.int8).toarray()
  array([[0, 0, 0, 0],
         [0, 0, 0, 0],
         [0, 0, 0, 0]], dtype=int8)
  
  >>> data = np.array([[1, 2, 3, 4]]).repeat(3, axis=0)
  >>> offsets = np.array([0, -1, 2])
  >>> dia_matrix((data, offsets), shape=(4, 4)).toarray()
  array([[1, 0, 3, 0],
         [1, 2, 0, 4],
         [0, 2, 3, 0],
         [0, 0, 3, 4]])
  
  >>> from scipy.sparse import dia_matrix
  >>> n = 10
  >>> ex = np.ones(n)
  >>> data = np.array([ex, 2 * ex, ex])
  >>> offsets = np.array([-1, 0, 1])
  >>> dia_matrix((data, offsets), shape=(n, n)).toarray()
  array([[2., 1., 0., ..., 0., 0., 0.],
         [1., 2., 1., ..., 0., 0., 0.],
         [0., 1., 2., ..., 0., 0., 0.],
         ...,
         [0., 0., 0., ..., 2., 1., 0.],
         [0., 0., 0., ..., 1., 2., 1.],
         [0., 0., 0., ..., 0., 1., 2.]])
code: def transpose(self, axes=None, copy=False):
      if axes is not None:
          raise ValueError(
              (
                  "Sparse matrices do not support "
                  "an 'axes' parameter because swapping "
                  "dimensions is the only logical permutation."
              )
          )
  
      num_rows, num_cols = self.shape
      max_dim = max(self.shape)
  
      # flip diagonal offsets
      offsets = -self.offsets
  
      # re-align the data matrix
      r = np.arange(len(offsets), dtype=np.intc)[:, None]
      c = (
          np.arange(num_rows, dtype=np.intc)
          - (offsets % max_dim)[:, None]
      )
      pad_amount = max(0, max_dim - self.data.shape[1])
      data = np.hstack(
          (
              self.data,
              np.zeros(
                  (self.data.shape[0], pad_amount),
                  dtype=self.data.dtype,
              ),
          )
      )
      data = data[r, c]
      return dia_matrix(
          (data, offsets), shape=(num_cols, num_rows), copy=copy
      )
  
imports: import numpy
  from .base import isspmatrix, _formats, spmatrix
  from .data import _data_matrix
  from .sputils import isshape, upcast_char, getdtype, get_index_dtype, get_sum_dtype, validateaxis, check_shape, matrix
  from ._sparsetools import dia_matvec
label_desc: Use image node_id 12 for calling the dia_matrix obj's underlying member method code with example usage: obj.transpose(axes, copy) and returns: dia_matrix