code: def fill_triangular(x, upper=False, name=None):
      """Creates a (batch of) triangular matrix from a vector of inputs.
  
      Created matrix can be lower- or upper-triangular. (It is more efficient to
      create the matrix as upper or lower, rather than transpose.)
  
      Triangular matrix elements are filled in a clockwise spiral. See example,
      below.
  
      If `x.shape` is `[b1, b2, ..., bB, d]` then the output shape is
      `[b1, b2, ..., bB, n, n]` where `n` is such that `d = n(n+1)/2`, i.e.,
      `n = int(np.sqrt(0.25 + 2. * m) - 0.5)`.
  
      Example:
  
      ```python
      fill_triangular([1, 2, 3, 4, 5, 6])
      # ==> [[4, 0, 0],
      #      [6, 5, 0],
      #      [3, 2, 1]]
  
      fill_triangular([1, 2, 3, 4, 5, 6], upper=True)
      # ==> [[1, 2, 3],
      #      [0, 5, 6],
      #      [0, 0, 4]]
      ```
  
      The key trick is to create an upper triangular matrix by concatenating `x`
      and a tail of itself, then reshaping.
  
      Suppose that we are filling the upper triangle of an `n`-by-`n` matrix `M`
      from a vector `x`. The matrix `M` contains n**2 entries total. The vector `x`
      contains `n * (n+1) / 2` entries. For concreteness, we'll consider `n = 5`
      (so `x` has `15` entries and `M` has `25`). We'll concatenate `x` and `x` with
      the first (`n = 5`) elements removed and reversed:
  
      ```python
      x = np.arange(15) + 1
      xc = np.concatenate([x, x[5:][::-1]])
      # ==> array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 15, 14, 13,
      #            12, 11, 10, 9, 8, 7, 6])
  
      # (We add one to the arange result to disambiguate the zeros below the
      # diagonal of our upper-triangular matrix from the first entry in `x`.)
  
      # Now, when reshapedlay this out as a matrix:
      y = np.reshape(xc, [5, 5])
      # ==> array([[ 1,  2,  3,  4,  5],
      #            [ 6,  7,  8,  9, 10],
      #            [11, 12, 13, 14, 15],
      #            [15, 14, 13, 12, 11],
      #            [10,  9,  8,  7,  6]])
  
      # Finally, zero the elements below the diagonal:
      y = np.triu(y, k=0)
      # ==> array([[ 1,  2,  3,  4,  5],
      #            [ 0,  7,  8,  9, 10],
      #            [ 0,  0, 13, 14, 15],
      #            [ 0,  0,  0, 12, 11],
      #            [ 0,  0,  0,  0,  6]])
      ```
  
      From this example we see that the resuting matrix is upper-triangular, and
      contains all the entries of x, as desired. The rest is details:
  
      - If `n` is even, `x` doesn't exactly fill an even number of rows (it fills
        `n / 2` rows and half of an additional row), but the whole scheme still
        works.
      - If we want a lower triangular matrix instead of an upper triangular,
        we remove the first `n` elements from `x` rather than from the reversed
        `x`.
  
      For additional comparisons, a pure numpy version of this function can be found
      in `distribution_util_test.py`, function `_fill_triangular`.
  
      Args:
        x: `Tensor` representing lower (or upper) triangular elements.
        upper: Python `bool` representing whether output matrix should be upper
          triangular (`True`) or lower triangular (`False`, default).
        name: Python `str`. The name to give this op.
  
      Returns:
        tril: `Tensor` with lower (or upper) triangular elements filled from `x`.
  
      Raises:
        ValueError: if `x` cannot be mapped to a triangular matrix.
      """
  
      with tf.name_scope(name or "fill_triangular"):
          x = tf.convert_to_tensor(x, name="x")
          m = tf.compat.dimension_value(
              tensorshape_util.with_rank_at_least(x.shape, 1)[-1]
          )
          if m is not None:
              # Formula derived by solving for n: m = n(n+1)/2.
              m = np.int32(m)
              n = np.sqrt(0.25 + 2.0 * m) - 0.5
              if n != np.floor(n):
                  raise ValueError(
                      "Input right-most shape ({}) does not "
                      "correspond to a triangular matrix.".format(m)
                  )
              n = np.int32(n)
              static_final_shape = tensorshape_util.concatenate(
                  x.shape[:-1], [n, n]
              )
          else:
              m = tf.shape(x)[-1]
              # For derivation, see above. Casting automatically lops off the 0.5, so we
              # omit it.  We don't validate n is an integer because this has
              # graph-execution cost; an error will be thrown from the reshape, below.
              n = tf.cast(
                  tf.sqrt(0.25 + tf.cast(2 * m, dtype=tf.float32)),
                  dtype=tf.int32,
              )
              static_final_shape = tensorshape_util.concatenate(
                  tensorshape_util.with_rank_at_least(x.shape, 1)[:-1],
                  [None, None],
              )
  
          # Try it out in numpy:
          #  n = 3
          #  x = np.arange(n * (n + 1) / 2)
          #  m = x.shape[0]
          #  n = np.int32(np.sqrt(.25 + 2 * m) - .5)
          #  x_tail = x[(m - (n**2 - m)):]
          #  np.concatenate([x_tail, x[::-1]], 0).reshape(n, n)  # lower
          #  # ==> array([[3, 4, 5],
          #               [5, 4, 3],
          #               [2, 1, 0]])
          #  np.concatenate([x, x_tail[::-1]], 0).reshape(n, n)  # upper
          #  # ==> array([[0, 1, 2],
          #               [3, 4, 5],
          #               [5, 4, 3]])
          #
          # Note that we can't simply do `x[..., -(n**2 - m):]` because this doesn't
          # correctly handle `m == n == 1`. Hence, we do nonnegative indexing.
          # Furthermore observe that:
          #   m - (n**2 - m)
          #   = n**2 / 2 + n / 2 - (n**2 - n**2 / 2 + n / 2)
          #   = 2 (n**2 / 2 + n / 2) - n**2
          #   = n**2 + n - n**2
          #   = n
          ndims = ps.rank(x)
          if upper:
              x_list = [x, tf.reverse(x[..., n:], axis=[ndims - 1])]
          else:
              x_list = [x[..., n:], tf.reverse(x, axis=[ndims - 1])]
          new_shape = (
              tensorshape_util.as_list(static_final_shape)
              if tensorshape_util.is_fully_defined(static_final_shape)
              else tf.concat([tf.shape(x)[:-1], [n, n]], axis=0)
          )
          x = tf.reshape(tf.concat(x_list, axis=-1), new_shape)
          x = tf.linalg.band_part(
              x,
              num_lower=(0 if upper else -1),
              num_upper=(-1 if upper else 0),
          )
          tensorshape_util.set_shape(x, static_final_shape)
          return x
  
imports: import numpy
  import tensorflow.compat.v1
  import tensorflow.compat.v2
  from tensorflow_probability.python.internal import assert_util
  from tensorflow_probability.python.internal import custom_gradient
  from tensorflow_probability.python.internal import distribution_util
  from tensorflow_probability.python.internal import dtype_util
  from tensorflow_probability.python.internal import prefer_static
  from tensorflow_probability.python.internal import tensorshape_util
  from tensorflow_probability.python.math import generic
label_desc: Use image node_id 14 for calling a global function with example usage: fill_triangular(x, upper, name) and returns: x