code: def _convert_to_spmatrix(operators):
          
          # Lazy import to improve `import odl` time
          import scipy.sparse
  
          # Convert ops to sparse representation. This is not trivial because
          # operators can be indexable themselves and give the wrong impression
          # of an extra dimension. So we have to infer the shape manually
          # first and extract the indices of nonzero positions.
          nrows = len(operators)
          ncols = None
          irow, icol, data = [], [], []
          for i, row in enumerate(operators):
              try:
                  iter(row)
              except TypeError:
                  raise ValueError(
                      '`operators` must be a matrix of `Operator` objects, `0` '
                      'or `None`, got {!r} (row {} = {!r} is not iterable)'
                      ''.format(operators, i, row))
  
              if isinstance(row, Operator):
                  raise ValueError(
                      '`operators` must be a matrix of `Operator` objects, `0` '
                      'or `None`, but row {} is an `Operator` {!r}'
                      ''.format(i, row))
  
              if ncols is None:
                  ncols = len(row)
              elif len(row) != ncols:
                  raise ValueError(
                      'all rows in `operators` must have the same length, but '
                      'length {} of row {} differs from previous common length '
                      '{}'.format(len(row), i, ncols))
  
              for j, col in enumerate(row):
                  if col is None or col is 0:
                      pass
                  elif isinstance(col, Operator):
                      irow.append(i)
                      icol.append(j)
                      data.append(col)
                  else:
                      raise ValueError(
                          '`operators` must be a matrix of `Operator` objects, '
                          '`0` or `None`, got entry {!r} at ({}, {})'
                          ''.format(col, i, j))
  
          # Create object array explicitly, threby avoiding erroneous conversion
          # in `coo_matrix.__init__`
          data_arr = np.empty(len(data), dtype=object)
          data_arr[:] = data
          return scipy.sparse.coo_matrix((data_arr, (irow, icol)),
                                         shape=(nrows, ncols))
docs: Convert an array-like object of operators to a sparse matrix.