class_docstr: Compute the GeneralizedExtremeValue CDF.
  
  Compute `Y = g(X) = exp(-t(X))`,
  
  where `t(x)` is defined to be:
    *`(1 + conc * (x - loc) / scale) ) ** (-1 / conc)` when `conc != 0`;
    *`exp(-(x - loc) / scale)` when `conc = 0`.
  
  This bijector maps inputs from the domain to `[0, 1]`, where the domain is
    * [loc - scale/conc, inf) when conc > 0;
    * (-inf, loc - scale/conc] when conc < 0;
    * (-inf, inf) when conc = 0;
  
  
  
  The inverse of the bijector applied to a uniform random variable
  `X ~ U(0, 1)` gives back a random variable with the
  [Generalized extreme value distribution](
  https://https://en.wikipedia.org/wiki/Generalized_extreme_value_distribution):
  
  When `concentration -> +-inf`, the probability mass concentrates near `loc`.
  
  ```none
  Y ~ GeneralizedExtremeValueCDF(loc, scale, conc)
  pdf(y; loc, scale, conc) = t(y; loc, scale, conc) ** (1 + conc) * exp(
  - t(y; loc, scale, conc) ) / scale
  where t(x) =
    * (1 + conc * (x - loc) / scale) ) ** (-1 / conc) when conc != 0;
    * exp(-(x - loc) / scale) when conc = 0.
  ```
code: def _maybe_assert_valid_x(
      self, x, loc=None, scale=None, concentration=None
  ):
      if not self.validate_args:
          return []
      loc = tf.convert_to_tensor(self.loc) if loc is None else loc
      scale = (
          tf.convert_to_tensor(self.scale) if scale is None else scale
      )
      concentration = (
          tf.convert_to_tensor(self.concentration)
          if concentration is None
          else concentration
      )
      # We intentionally compute the boundary with (1.0 / concentration) * scale
      # instead of just scale / concentration.
      # Why?  The sampler returns loc + (foo / concentration) * scale,
      # and at high-ish values of concentration, foo has a decent
      # probability of being numerically exactly -1.  We therefore mimic
      # the pattern of round-off that occurs in the sampler to make sure
      # that samples emitted from this distribution will pass its own
      # validations.  This is sometimes necessary: in TF's float32,
      #   0.69314826 / 37.50019 < (1.0 / 37.50019) * 0.69314826
      boundary = loc - (1.0 / concentration) * scale
      # The support of this bijector depends on the sign of concentration.
      is_in_bounds = tf.where(
          concentration > 0.0, x >= boundary, x <= boundary
      )
      # For concentration 0, the domain is the whole line.
      is_in_bounds = is_in_bounds | tf.math.equal(concentration, 0.0)
  
      return [
          assert_util.assert_equal(
              is_in_bounds,
              True,
              message="Forward transformation input must be inside domain.",
          )
      ]
  
imports: import tensorflow.compat.v2
  from tensorflow_probability.python.bijectors import bijector
  from tensorflow_probability.python.bijectors import softplus
  from tensorflow_probability.python.internal import assert_util
  from tensorflow_probability.python.internal import dtype_util
  from tensorflow_probability.python.internal import parameter_properties
  from tensorflow_probability.python.internal import tensor_util
label_desc: Use image node_id 11 for calling the GeneralizedExtremeValueCDF obj's underlying member method code with example usage: obj._maybe_assert_valid_x(x, loc, scale, concentration) and returns: list, list