class_docstr: `LinearOperator` acting like a [batch] zero matrix.
  
  This operator acts like a [batch] zero matrix `A` with shape
  `[B1,...,Bb, N, M]` 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 M` matrix.  This matrix `A` is not materialized, but for
  purposes of broadcasting this shape will be relevant.
  
  `LinearOperatorZeros` is initialized with `num_rows`, and optionally
  `num_columns, `batch_shape`, and `dtype` arguments.  If `num_columns` is
  `None`, then this operator will be initialized as a square matrix. If
  `batch_shape` is `None`, this operator efficiently passes through all
  arguments.  If `batch_shape` is provided, broadcasting may occur, which will
  require making copies.
  
  ```python
  # Create a 2 x 2 zero matrix.
  operator = LinearOperatorZero(num_rows=2, dtype=tf.float32)
  
  operator.to_dense()
  ==> [[0., 0.]
       [0., 0.]]
  
  operator.shape
  ==> [2, 2]
  
  operator.determinant()
  ==> 0.
  
  x = ... Shape [2, 4] Tensor
  operator.matmul(x)
  ==> Shape [2, 4] Tensor, same as x.
  
  # Create a 2-batch of 2x2 zero matrices
  operator = LinearOperatorZeros(num_rows=2, batch_shape=[2])
  operator.to_dense()
  ==> [[[0., 0.]
        [0., 0.]],
       [[0., 0.]
        [0., 0.]]]
  
  # Here, even though the operator has a batch shape, the input is the same as
  # the output, so x can be passed through without a copy.  The operator is able
  # to detect that no broadcast is necessary because both x and the operator
  # have statically defined shape.
  x = ... Shape [2, 2, 3]
  operator.matmul(x)
  ==> Shape [2, 2, 3] Tensor, same as tf.zeros_like(x)
  
  # Here the operator and x have different batch_shape, and are broadcast.
  # This requires a copy, since the output is different size than the input.
  x = ... Shape [1, 2, 3]
  operator.matmul(x)
  ==> Shape [2, 2, 3] Tensor, equal to tf.zeros_like([x, x])
  ```
  
  ### Shape compatibility
  
  This operator acts on [batch] matrix with compatible shape.
  `x` is a batch matrix with compatible shape for `matmul` and `solve` if
  
  ```
  operator.shape = [B1,...,Bb] + [N, M],  with b >= 0
  x.shape =   [C1,...,Cc] + [M, 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.
docstr: Initialize a `LinearOperatorZeros`.
  
  The `LinearOperatorZeros` is initialized with arguments defining `dtype`
  and shape.
  
  This operator is able to broadcast the leading (batch) dimensions, which
  sometimes requires copying data.  If `batch_shape` is `None`, the operator
  can take arguments of any batch shape without copying.  See examples.
  
  Args:
    num_rows:  Scalar non-negative integer `Tensor`.  Number of rows in the
      corresponding zero matrix.
    num_columns:  Scalar non-negative integer `Tensor`.  Number of columns in
      the corresponding zero matrix. If `None`, defaults to the value of
      `num_rows`.
    batch_shape:  Optional `1-D` integer `Tensor`.  The shape of the leading
      dimensions.  If `None`, this operator has no leading dimensions.
    dtype:  Data type of the matrix that this operator represents.
    is_non_singular:  Expect that this operator is non-singular.
    is_self_adjoint:  Expect that this operator is equal to its hermitian
      transpose.
    is_positive_definite:  Expect that this operator is positive definite,
      meaning the quadratic form `x^H A x` has positive real part for all
      nonzero `x`.  Note that we do not require the operator to be
      self-adjoint to be positive-definite.  See:
      https://en.wikipedia.org/wiki/Positive-definite_matrix#Extension_for_non-symmetric_matrices
    is_square:  Expect that this operator acts like square [batch] matrices.
    assert_proper_shapes:  Python `bool`.  If `False`, only perform static
      checks that initialization and method arguments have proper shape.
      If `True`, and static checks are inconclusive, add asserts to the graph.
    name: A name for this `LinearOperator`
  
  Raises:
    ValueError:  If `num_rows` is determined statically to be non-scalar, or
      negative.
    ValueError:  If `num_columns` is determined statically to be non-scalar,
      or negative.
    ValueError:  If `batch_shape` is determined statically to not be 1-D, or
      negative.
    ValueError:  If any of the following is not `True`:
      `{is_self_adjoint, is_non_singular, is_positive_definite}`.
code: def __init__(
      self,
      num_rows,
      num_columns=None,
      batch_shape=None,
      dtype=None,
      is_non_singular=False,
      is_self_adjoint=True,
      is_positive_definite=False,
      is_square=True,
      assert_proper_shapes=False,
      name="LinearOperatorZeros",
  ):
      r"""Initialize a `LinearOperatorZeros`.
  
      The `LinearOperatorZeros` is initialized with arguments defining `dtype`
      and shape.
  
      This operator is able to broadcast the leading (batch) dimensions, which
      sometimes requires copying data.  If `batch_shape` is `None`, the operator
      can take arguments of any batch shape without copying.  See examples.
  
      Args:
        num_rows:  Scalar non-negative integer `Tensor`.  Number of rows in the
          corresponding zero matrix.
        num_columns:  Scalar non-negative integer `Tensor`.  Number of columns in
          the corresponding zero matrix. If `None`, defaults to the value of
          `num_rows`.
        batch_shape:  Optional `1-D` integer `Tensor`.  The shape of the leading
          dimensions.  If `None`, this operator has no leading dimensions.
        dtype:  Data type of the matrix that this operator represents.
        is_non_singular:  Expect that this operator is non-singular.
        is_self_adjoint:  Expect that this operator is equal to its hermitian
          transpose.
        is_positive_definite:  Expect that this operator is positive definite,
          meaning the quadratic form `x^H A x` has positive real part for all
          nonzero `x`.  Note that we do not require the operator to be
          self-adjoint to be positive-definite.  See:
          https://en.wikipedia.org/wiki/Positive-definite_matrix#Extension_for_non-symmetric_matrices
        is_square:  Expect that this operator acts like square [batch] matrices.
        assert_proper_shapes:  Python `bool`.  If `False`, only perform static
          checks that initialization and method arguments have proper shape.
          If `True`, and static checks are inconclusive, add asserts to the graph.
        name: A name for this `LinearOperator`
  
      Raises:
        ValueError:  If `num_rows` is determined statically to be non-scalar, or
          negative.
        ValueError:  If `num_columns` is determined statically to be non-scalar,
          or negative.
        ValueError:  If `batch_shape` is determined statically to not be 1-D, or
          negative.
        ValueError:  If any of the following is not `True`:
          `{is_self_adjoint, is_non_singular, is_positive_definite}`.
      """
      parameters = dict(
          num_rows=num_rows,
          num_columns=num_columns,
          batch_shape=batch_shape,
          dtype=dtype,
          is_non_singular=is_non_singular,
          is_self_adjoint=is_self_adjoint,
          is_positive_definite=is_positive_definite,
          is_square=is_square,
          assert_proper_shapes=assert_proper_shapes,
          name=name,
      )
  
      dtype = dtype or dtypes.float32
      self._assert_proper_shapes = assert_proper_shapes
  
      with ops.name_scope(name):
          dtype = dtypes.as_dtype(dtype)
          if not is_self_adjoint and is_square:
              raise ValueError(
                  "A zero operator is always self adjoint."
              )
          if is_non_singular:
              raise ValueError("A zero operator is always singular.")
          if is_positive_definite:
              raise ValueError(
                  "A zero operator is always not positive-definite."
              )
  
          super(LinearOperatorZeros, self).__init__(
              dtype=dtype,
              is_non_singular=is_non_singular,
              is_self_adjoint=is_self_adjoint,
              is_positive_definite=is_positive_definite,
              is_square=is_square,
              parameters=parameters,
              name=name,
          )
  
          linear_operator_util.assert_not_ref_type(num_rows, "num_rows")
          linear_operator_util.assert_not_ref_type(
              num_columns, "num_columns"
          )
          linear_operator_util.assert_not_ref_type(
              batch_shape, "batch_shape"
          )
  
          self._num_rows = linear_operator_util.shape_tensor(
              num_rows, name="num_rows"
          )
          self._num_rows_static = tensor_util.constant_value(
              self._num_rows
          )
  
          if num_columns is None:
              num_columns = num_rows
  
          self._num_columns = linear_operator_util.shape_tensor(
              num_columns, name="num_columns"
          )
          self._num_columns_static = tensor_util.constant_value(
              self._num_columns
          )
  
          self._check_domain_range_possibly_add_asserts()
  
          if (
              self._num_rows_static is not None
              and self._num_columns_static is not None
          ):
              if (
                  is_square
                  and self._num_rows_static != self._num_columns_static
              ):
                  raise ValueError(
                      "LinearOperatorZeros initialized as is_square=True, but got "
                      "num_rows({}) != num_columns({})".format(
                          self._num_rows_static,
                          self._num_columns_static,
                      )
                  )
  
          if batch_shape is None:
              self._batch_shape_arg = None
          else:
              self._batch_shape_arg = linear_operator_util.shape_tensor(
                  batch_shape, name="batch_shape_arg"
              )
              self._batch_shape_static = tensor_util.constant_value(
                  self._batch_shape_arg
              )
              self._check_batch_shape_possibly_add_asserts()
  
imports: import numpy
  from tensorflow.python.framework import dtypes
  from tensorflow.python.framework import errors
  from tensorflow.python.framework import ops
  from tensorflow.python.framework import tensor_shape
  from tensorflow.python.framework import tensor_util
  from tensorflow.python.ops import array_ops
  from tensorflow.python.ops import array_ops_stack
  from tensorflow.python.ops import check_ops
  from tensorflow.python.ops import control_flow_ops
  from tensorflow.python.ops import math_ops
  from tensorflow.python.ops.linalg import linalg_impl
  from tensorflow.python.ops.linalg import linear_operator
  from tensorflow.python.ops.linalg import linear_operator_util
  from tensorflow.python.util.tf_export import tf_export
label_desc: Use image node_id 1 to create a new LinearOperatorZeros object from inherited base classes: linear_operator with example: obj = LinearOperatorZeros(num_rows, num_columns, batch_shape, dtype, is_non_singular, is__adjoint, is_positive_definite, is_square, assert_proper_shapes, name)