docs: def define_unit(
      symbol, value, tex_repr=None, offset=None, prefixable=False, registry=None
  ):
      """
      Define a new unit and add it to the specified unit registry.
  
      Parameters
      ----------
      symbol : string
          The symbol for the new unit.
      value : tuple or :class:`unyt.array.unyt_quantity`
          The definition of the new unit in terms of some other units. For
          example, one would define a new "mph" unit with ``(1.0, "mile/hr")``
          or with ``1.0*unyt.mile/unyt.hr``
      tex_repr : string, optional
          The LaTeX representation of the new unit. If one is not supplied, it
          will be generated automatically based on the symbol string.
      offset : float, optional
          The default offset for the unit. If not set, an offset of 0 is assumed.
      prefixable : boolean, optional
          Whether or not the new unit can use SI prefixes. Default: False
      registry : :class:`unyt.unit_registry.UnitRegistry` or None
          The unit registry to add the unit to. If None, then defaults to the
          global default unit registry. If registry is set to None then the
          unit object will be added as an attribute to the top-level :mod:`unyt`
          namespace to ease working with the newly defined unit. See the example
          below.
  
      Examples
      --------
      >>> from unyt import day
      >>> two_weeks = 14.0*day
      >>> one_day = 1.0*day
      >>> define_unit("two_weeks", two_weeks)
      >>> from unyt import two_weeks
      >>> print((3*two_weeks)/one_day)
      42.0 dimensionless
      """
      from unyt.array import unyt_quantity, _iterable
      import unyt
  
      if registry is None:
          registry = default_unit_registry
      if symbol in registry:
          raise RuntimeError(
              "Unit symbol '%s' already exists in the provided " "registry" % symbol
          )
      if not isinstance(value, unyt_quantity):
          if _iterable(value) and len(value) == 2:
              value = unyt_quantity(value[0], value[1], registry=registry)
          else:
              raise RuntimeError(
                  '"value" needs to be a quantity or ' "(value, unit) tuple!"
              )
      base_value = float(value.in_base(unit_system="mks"))
      dimensions = value.units.dimensions
      registry.add(
          symbol,
          base_value,
          dimensions,
          prefixable=prefixable,
          tex_repr=tex_repr,
          offset=offset,
      )
      if registry is default_unit_registry:
          u = Unit(symbol, registry=registry)
          setattr(unyt, symbol, u)