class_docstr: The vectorization of the Exponential distribution on `R^k`.
  
  The vector exponential distribution is defined over a subset of `R^k`, and
  parameterized by a (batch of) length-`k` `loc` vector and a (batch of) `k x k`
  `scale` matrix:  `covariance = scale @ scale.T`, where `@` denotes
  matrix-multiplication.
  
  #### Mathematical Details
  
  The probability density function (pdf) is
  
  ```none
  pdf(y; loc, scale) = exp(-||x||_1) / Z,  for y in S(loc, scale),
  x = inv(scale) @ (y - loc),
  Z = |det(scale)|,
  ```
  
  where:
  
  * `loc` is a vector in `R^k`,
  * `scale` is a linear operator in `R^{k x k}`, `cov = scale @ scale.T`,
  * `S = {loc + scale @ x : x in R^k, x_1 > 0, ..., x_k > 0}`, is an image of
     the positive half-space,
  * `||x||_1` denotes the `l1` norm of `x`, `sum_i |x_i|`,
  * `Z` denotes the normalization constant.
  
  The VectorExponential distribution is a member of the [location-scale
  family](https://en.wikipedia.org/wiki/Location-scale_family), i.e., it can be
  constructed as,
  
  ```none
  X = (X_1, ..., X_k), each X_i ~ Exponential(rate=1)
  Y = (Y_1, ...,Y_k) = scale @ X + loc
  ```
  
  #### About `VectorExponential` and `Vector` distributions in TensorFlow.
  
  The `VectorExponential` is a non-standard distribution that has useful
  properties.
  
  The marginals `Y_1, ..., Y_k` are *not* Exponential random variables, due to
  the fact that the sum of Exponential random variables is not Exponential.
  
  Instead, `Y` is a vector whose components are linear combinations of
  Exponential random variables.  Thus, `Y` lives in the vector space generated
  by `vectors` of Exponential distributions.  This allows the user to decide the
  mean and covariance (by setting `loc` and `scale`), while preserving some
  properties of the Exponential distribution.  In particular, the tails of `Y_i`
  will be (up to polynomial factors) exponentially decaying.
  
  To see this last statement, note that the pdf of `Y_i` is the convolution of
  the pdf of `k` independent Exponential random variables.  One can then show by
  induction that distributions with exponential (up to polynomial factors) tails
  are closed under convolution.
  
  
  #### Examples
  
  ```python
  tfd = tfp.distributions
  
  # Initialize a single 2-variate VectorExponential, supported on
  # {(x, y) in R^2 : x > 0, y > 0}.
  mat = [[1.0, 0.1],
         [0.1, 1.0]]
  
  vex = tfd.VectorExponentialLinearOperator(
      scale=tf.linalg.LinearOperatorFullMatrix(mat))
  
  # Compute the pdf of an `R^2` observation; return a scalar.
  vex.prob([1., 2.])  # shape: []
  
  # Initialize a 2-batch of 3-variate Vector Exponential's.
  mu = [[1., 2, 3],
        [1., 0, 0]]              # shape: [2, 3]
  scale_diag = [[1., 2, 3],
                [0.5, 1, 1.5]]     # shape: [2, 3]
  
  vex = tfd.VectorExponentialLinearOperator(
      loc=mu,
      scale=tf.linalg.LinearOperatorDiag(scale_diag))
  
  # Compute the pdf of two `R^3` observations; return a length-2 vector.
  x = [[1.9, 2.2, 3.1],
       [10., 1.0, 9.0]]     # shape: [2, 3]
  vex.prob(x)    # shape: [2]
  ```
docstr: The `scale` `LinearOperator` in `Y = scale @ X + loc`.
docstr_tok: ["The","`","scale","`","`","LinearOperator","`","in","`","Y","=","scale","@","X","+","loc","`","."]
code: def scale(self):
      """The `scale` `LinearOperator` in `Y = scale @ X + loc`."""
      return self._scale
  
imports: import tensorflow.compat.v2
  from tensorflow_probability.python.bijectors import chain
  from tensorflow_probability.python.bijectors import scale_matvec_linear_operator
  from tensorflow_probability.python.bijectors import shift
  from tensorflow_probability.python.bijectors import softplus
  from tensorflow_probability.python.distributions import exponential
  from tensorflow_probability.python.distributions import sample
  from tensorflow_probability.python.distributions import transformed_distribution
  from tensorflow_probability.python.internal import assert_util
  from tensorflow_probability.python.internal import distribution_util
  from tensorflow_probability.python.internal import dtype_util
  from tensorflow_probability.python.internal import tensorshape_util
label_desc: Use image node_id 3 for calling the VectorExponentialLinearOperator obj's underlying member method code with example usage: obj.scale() and returns: self