class_docstr: `LinearOperator` acting like a [batch] of Householder transformations.
  
  This operator acts like a [batch] of householder reflections with shape
  `[B1,...,Bb, N, N]` for some `b >= 0`.  The first `b` indices index a
  batch member.  For every batch index `(i1,...,ib)`, `A[i1,...,ib, : :]` is
  an `N x N` matrix.  This matrix `A` is not materialized, but for
  purposes of broadcasting this shape will be relevant.
  
  `LinearOperatorHouseholder` is initialized with a (batch) vector.
  
  A Householder reflection, defined via a vector `v`, which reflects points
  in `R^n` about the hyperplane orthogonal to `v` and through the origin.
  
  ```python
  # Create a 2 x 2 householder transform.
  vec = [1 / np.sqrt(2), 1. / np.sqrt(2)]
  operator = LinearOperatorHouseholder(vec)
  
  operator.to_dense()
  ==> [[0.,  -1.]
       [-1., -0.]]
  
  tensor_shape.TensorShape(operator.shape)
  ==> [2, 2]
  
  operator.log_abs_determinant()
  ==> scalar Tensor
  
  x = ... Shape [2, 4] Tensor
  operator.matmul(x)
  ==> Shape [2, 4] Tensor
  ```
  
  #### Shape compatibility
  
  This operator acts on [batch] matrix with compatible shape.
  `x` is a batch matrix with compatible shape for `matmul` and `solve` if
  
  ```
  tensor_shape.TensorShape(operator.shape) = [B1,...,Bb] + [N, N],  with b >= 0
  tensor_shape.TensorShape(x.shape) =   [C1,...,Cc] + [N, R],
  and [C1,...,Cc] broadcasts with [B1,...,Bb] to [D1,...,Dd]
  ```
  
  #### Matrix property hints
  
  This `LinearOperator` is initialized with boolean flags of the form `is_X`,
  for `X = non_singular, self_adjoint, positive_definite, square`.
  These have the following meaning:
  
  * If `is_X == True`, callers should expect the operator to have the
    property `X`.  This is a promise that should be fulfilled, but is *not* a
    runtime assert.  For example, finite floating point precision may result
    in these promises being violated.
  * If `is_X == False`, callers should expect the operator to not have `X`.
  * If `is_X == None` (the default), callers should have no expectation either
    way.
code: def _eigvals(self):
      # We have (n - 1) +1 eigenvalues and a single -1 eigenvalue.
      result_shape = prefer_static.shape(self.reflection_axis)
      n = result_shape[-1]
      ones_shape = prefer_static.concat(
          [result_shape[:-1], [n - 1]], axis=-1
      )
      neg_shape = prefer_static.concat(
          [result_shape[:-1], [1]], axis=-1
      )
      eigvals = array_ops.ones(shape=ones_shape, dtype=self.dtype)
      eigvals = prefer_static.concat(
          [-array_ops.ones(shape=neg_shape, dtype=self.dtype), eigvals],
          axis=-1,
      )  # pylint: disable=invalid-unary-operand-type
      return eigvals
  
imports: from tensorflow_probability.python.internal.backend.numpy import errors
  from tensorflow_probability.python.internal.backend.numpy import ops
  from tensorflow_probability.python.internal.backend.numpy import numpy_array
  from tensorflow_probability.python.internal.backend.numpy import control_flow
  from tensorflow_probability.python.internal.backend.numpy import numpy_math
  from tensorflow_probability.python.internal.backend.numpy import nn
  from tensorflow_probability.python.internal.backend.numpy import linalg_impl
  from tensorflow_probability.python.internal.backend.numpy.gen import linear_operator
  from tensorflow_probability.python.internal.backend.numpy.gen import linear_operator_util
  import numpy
  from tensorflow_probability.python.internal.backend.numpy import linalg_impl
  from tensorflow_probability.python.internal.backend.numpy import ops
  from tensorflow_probability.python.internal.backend.numpy.gen import tensor_shape
  from tensorflow_probability.python.internal.backend.numpy import private
label_desc: Use image node_id 17 for calling the LinearOperatorHouseholder obj's underlying member method code with example usage: obj._eigvals() and returns: eigvals