docs: def convert_to_units(self, units, equivalence=None, **kwargs):
          """
          Convert the array to the given units in-place.
  
          Optionally, an equivalence can be specified to convert to an
          equivalent quantity which is not in the same dimensions.
  
          Parameters
          ----------
          units : Unit object or string
              The units you want to convert to.
          equivalence : string, optional
              The equivalence you wish to use. To see which equivalencies
              are supported for this object, try the ``list_equivalencies``
              method. Default: None
          kwargs: optional
              Any additional keyword arguments are supplied to the equivalence
  
          Raises
          ------
          If the provided unit does not have the same dimensions as the array
          this will raise a UnitConversionError
  
          Examples
          --------
  
          >>> from unyt import cm, km
          >>> length = [3000, 2000, 1000]*cm
          >>> length.convert_to_units('m')
          >>> print(length)
          [30. 20. 10.] m
          """
          units = _sanitize_units_convert(units, self.units.registry)
          if equivalence is None:
              conv_data = _check_em_conversion(
                  self.units, units, registry=self.units.registry
              )
              if any(conv_data):
                  new_units, (conv_factor, offset) = _em_conversion(
                      self.units, conv_data, units
                  )
              else:
                  new_units = units
                  (conv_factor, offset) = self.units.get_conversion_factor(
                      new_units, self.dtype
                  )
  
              self.units = new_units
              values = self.d
              # if our dtype is an integer do the following somewhat awkward
              # dance to change the dtype in-place. We can't use astype
              # directly because that will create a copy and not update self
              if self.dtype.kind in ("u", "i"):
                  # create a copy of the original data in floating point
                  # form, it's possible this may lose precision for very
                  # large integers
                  dsize = values.dtype.itemsize
                  new_dtype = "f" + str(dsize)
                  large = LARGE_INPUT.get(dsize, 0)
                  if large and np.any(np.abs(values) > large):
                      warnings.warn(
                          "Overflow encountered while converting to units '%s'"
                          % new_units,
                          RuntimeWarning,
                          stacklevel=2,
                      )
                  float_values = values.astype(new_dtype)
                  # change the dtypes in-place, this does not change the
                  # underlying memory buffer
                  values.dtype = new_dtype
                  self.dtype = new_dtype
                  # actually fill in the new float values now that our
                  # dtype is correct
                  np.copyto(values, float_values)
              values *= conv_factor
  
              if offset:
                  np.subtract(values, offset, values)
          else:
              self.convert_to_equivalent(units, equivalence, **kwargs)