class_docstr: Compute `Y = g(X; scale) = scale @ X` for blockwise `X` and `scale`.
  
  `scale` is a `LinearOperator` that supports blockwise semantics, e.g.
  `LinearOperatorBlockDiag` or `LinearOperatorBlockLowerTriangular`. The forward
  transformation is: `scale @ X` where `X` is a list or tuple of `Tensor`s, the
  rightmost dimensions of which match the `domain_dimension`s of the
  corresponding operators in `scale`'s block structure.
  
  Example use:
  
  ```python
  op_1 = tf.linalg.LinearOperatorDiag(diag=[1., -1., 3.])
  op_2 = tf.linalg.LinearOperatorFullMatrix([[12., 5.], [-1., 3.]])
  scale = tf.linalg.LinearOperatorBlockDiag([op_1, op_2], is_non_singular=True)
  bijector = ScaleMatvecLinearOperatorBlock(scale)
  
  x = [[2., 0., 1.], [3., 1.]]  # Input consisting of two blocks
  y = bijector.forward(x)  # [Tensor([2., 0., 3.]), Tensor([41., 0.])]
  ```
class_docstr_tok: ["Compute","`","Y","=","g","(","X",";","scale",")","=","scale","@","X","`","for","blockwise","`","X","`","and","`","scale","`",".","`","scale","`","is","a","`","LinearOperator","`","that","supports","blockwise","semantics",",","e.g",".","`","LinearOperatorBlockDiag","`","or","`","LinearOperatorBlockLowerTriangular","`",".","The","forward","transformation","is",":","`","scale","@","X","`","where","`","X","`","is","a","list","or","tuple","of","`","Tensor","`","s",",","the","rightmost","dimensions","of","which","match","the","`","domain_dimension","`","s","of","the","corresponding","operators","in","`","scale","`","'s","block","structure",".","Example","use",":","``","`","python","op_1","=","tf.linalg.LinearOperatorDiag","(","diag=","[","1.",",","-1.",",","3",".","]",")","op_2","=","tf.linalg.LinearOperatorFullMatrix","(","[","[","12.",",","5",".","]",",","[","-1.",",","3",".","]","]",")","scale","=","tf.linalg.LinearOperatorBlockDiag","(","[","op_1",",","op_2","]",",","is_non_singular=True",")","bijector","=","ScaleMatvecLinearOperatorBlock","(","scale",")","x","=","[","[","2.",",","0.",",","1",".","]",",","[","3.",",","1",".","]","]","#","Input","consisting","of","two","blocks","y","=","bijector.forward","(","x",")","#","[","Tensor","(","[","2.",",","0.",",","3",".","]",")",",","Tensor","(","[","41.",",","0",".","]",")","]","``","`"]
docstr: Instantiates the `ScaleMatvecLinearOperatorBlock` bijector.
  
  Args:
    scale:  Subclass of `LinearOperator` that supports blockwise semantics
      (e.g. `LinearOperatorBlockDiag` or
      `LinearOperatorBlockLowerTriangular`). Represents the (blockwise, batch,
      non-singular) linear transformation by which the `Bijector` transforms
      inputs.
    adjoint: Python `bool` indicating whether to use the `scale` matrix as
      specified or its adjoint.
      Default value: `False`.
    validate_args: Python `bool` indicating whether arguments should be
      checked for correctness.
    parameters: Locals dict captured by subclass constructor, to be used for
      copy/slice re-instantiation operators.
    name: Python `str` name given to ops managed by this object.
  
  Raises:
    TypeError: if `scale` is not a `LinearOperator`.
    ValueError: if not `scale.is_non_singular`.
docstr_tok: ["Instantiates","the","`","ScaleMatvecLinearOperatorBlock","`","bijector",".","Args",":","scale",":","Subclass","of","`","LinearOperator","`","that","supports","blockwise","semantics","(","e.g",".","`","LinearOperatorBlockDiag","`","or","`","LinearOperatorBlockLowerTriangular","`",")",".","Represents","the","(","blockwise",",","batch",",","non-singular",")","linear","transformation","by","which","the","`","Bijector","`","transforms","inputs",".","adjoint",":","Python","`","bool","`","indicating","whether","to","use","the","`","scale","`","matrix","as","specified","or","its","adjoint",".","Default","value",":","`","False","`",".","validate_args",":","Python","`","bool","`","indicating","whether","arguments","should","be","checked","for","correctness",".","parameters",":","Locals","dict","captured","by","subclass","constructor",",","to","be","used","for","copy\/slice","re-instantiation","operators",".","name",":","Python","`","str","`","name","given","to","ops","managed","by","this","object",".","Raises",":","TypeError",":","if","`","scale","`","is","not","a","`","LinearOperator","`",".","ValueError",":","if","not","`","scale.is_non_singular","`","."]
code: def __init__(
      self,
      scale,
      adjoint=False,
      validate_args=False,
      parameters=None,
      name="scale_matvec_linear_operator_block",
  ):
      """Instantiates the `ScaleMatvecLinearOperatorBlock` bijector.
  
      Args:
        scale:  Subclass of `LinearOperator` that supports blockwise semantics
          (e.g. `LinearOperatorBlockDiag` or
          `LinearOperatorBlockLowerTriangular`). Represents the (blockwise, batch,
          non-singular) linear transformation by which the `Bijector` transforms
          inputs.
        adjoint: Python `bool` indicating whether to use the `scale` matrix as
          specified or its adjoint.
          Default value: `False`.
        validate_args: Python `bool` indicating whether arguments should be
          checked for correctness.
        parameters: Locals dict captured by subclass constructor, to be used for
          copy/slice re-instantiation operators.
        name: Python `str` name given to ops managed by this object.
  
      Raises:
        TypeError: if `scale` is not a `LinearOperator`.
        ValueError: if not `scale.is_non_singular`.
      """
      parameters = dict(locals()) if parameters is None else parameters
      with tf.name_scope(name) as name:
          dtype = dtype_util.common_dtype(
              [scale], dtype_hint=tf.float32
          )
          if not hasattr(scale, "is_non_singular"):
              raise TypeError(
                  "scale does not implement the interface of tf.LinearOperator "
                  "(saw: {}).".format(scale)
              )
          if validate_args and not scale.is_non_singular:
              raise ValueError("Scale matrix must be non-singular.")
  
          forward_min_event_ndims = [1] * len(scale.operators)
  
          self._scale = scale
          self._adjoint = adjoint
          super(ScaleMatvecLinearOperatorBlock, self).__init__(
              forward_min_event_ndims=forward_min_event_ndims,
              is_constant_jacobian=True,
              dtype=dtype,
              validate_args=validate_args,
              parameters=parameters,
              name=name,
          )
  
          if tensorshape_util.is_fully_defined(self._scale.batch_shape):
              self._parameter_batch_shape = self._scale.batch_shape
          else:
              self._parameter_batch_shape = (
                  self._scale.batch_shape_tensor()
              )
  
imports: import tensorflow.compat.v2
  from tensorflow_probability.python.bijectors import bijector
  from tensorflow_probability.python.internal import dtype_util
  from tensorflow_probability.python.internal import parameter_properties
  from tensorflow_probability.python.internal import prefer_static
  from tensorflow_probability.python.internal import tensor_util
  from tensorflow_probability.python.internal import tensorshape_util
label_desc: Use image node_id 1 to create a new ScaleMatvecLinearOperatorBlock object from inherited base classes: _ScaleMatvecLinearOperatorBase with example: obj = ScaleMatvecLinearOperatorBlock(scale, adjoint, validate_args, parameters, name)