docs: def _asym_transform_deriv_v(systematic_utilities,
                              alt_IDs,
                              rows_to_alts,
                              eta,
                              ref_position=None,
                              output_array=None,
                              *args, **kwargs):
      """
      Parameters
      ----------
      systematic_utilities : 1D ndarray.
          Contains the systematic utilities for each each available alternative
          for each observation. All elements should be ints, floats, or longs.
      alt_IDs : 1D ndarray.
         All elements should be ints. There should be one row per obervation per
         available alternative for the given observation. Elements denote the
         alternative corresponding to the given row of the design matrix.
      rows_to_alts : 2D ndarray.
          There should be one row per observation per available alternative and
          one column per possible alternative. This matrix maps the rows of the
          design matrix to the possible alternatives for this dataset.
      eta : 1D ndarray.
          Each element should be an int, float, or long. There should be one
          value per transformed shape parameter. Note that if there are J
          possible alternatives in the dataset, then there should be J - 1
          elements in `eta`.
      ref_position : int.
          Specifies the position in the array of natural shape parameters that
          should be equal to 1 - the sum of the other elements. Specifies the
          alternative in the ordered array of unique alternatives that is not
          having its shape parameter estimated (to ensure identifiability).
      output_array : 2D scipy sparse matrix.
          This matrix's data is to be replaced with the correct derivatives of
          the transformation vector with respect to the vector of systematic
          utilities.
  
      Returns
      -------
      output_array : 2D scipy sparse matrix.
          Will be a square matrix with `systematic_utilities.shape[0]` rows and
          columns. `output_array` specifies the derivative of the transformed
          utilities with respect to the index, V.
      """
      ##########
      # Convert the reduced shape parameters to the natural shape parameters
      ##########
      natural_shape_params = _convert_eta_to_c(eta, ref_position)
  
      ##########
      # Calculate the derivative of the transformed utilities with respect to
      # the systematic utilities
      ##########
      # Create a vector which contains the appropriate shape for each row in the
      # design matrix
      long_shapes = rows_to_alts.dot(natural_shape_params)
  
      # Determine how many alternatives there are
      num_alts = rows_to_alts.shape[1]
  
      # Get the natural log of the long_shapes
      log_long_shapes = np.log(long_shapes)
      # Guard against underflow, aka long_shapes too close to zero.
      # I assume this should never happen because convert_eta_to_c never outputs
      # zeros, by design.
      log_long_shapes[np.isneginf(log_long_shapes)] = -1 * max_comp_value
  
      # Get the natural log of (1 - long_shapes) / (num_alts - 1)
      log_1_sub_long_shapes = np.log((1 - long_shapes) /
                                     (num_alts - 1))
      # Guard against underflow, aka 1 - long_shapes too close to zero.
      small_idx = np.isneginf(log_1_sub_long_shapes)
      log_1_sub_long_shapes[small_idx] = -1 * max_comp_value
  
      # Calculate the derivative of h_ij with respect to v_ij
      # Note that the derivative of h_ij with respect to any other systematic
      # utility is zero.
      derivs = -1 * ((systematic_utilities >= 0).astype(int) *
                     log_long_shapes +
                     (systematic_utilities < 0).astype(int) *
                     log_1_sub_long_shapes)
  
      output_array.data = derivs
  
      # Return the matrix of dh_dv. Note the off-diagonal entries are zero
      # because each transformation only depends on its value of v and no others
      return output_array