@tf_export('linalg.matvec')
def matvec(a, b, transpose_a=False, adjoint_a=False, a_is_sparse=False, b_is_sparse=False, name=None):
    'Multiplies matrix `a` by vector `b`, producing `a` * `b`.\n\n  The matrix `a` must, following any transpositions, be a tensor of rank >= 2,\n  and we must have `shape(b) = shape(a)[:-2] + [shape(a)[-1]]`.\n\n  Both `a` and `b` must be of the same type. The supported types are:\n  `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n  Matrix `a` can be transposed or adjointed (conjugated and transposed) on\n  the fly by setting one of the corresponding flag to `True`. These are `False`\n  by default.\n\n  If one or both of the inputs contain a lot of zeros, a more efficient\n  multiplication algorithm can be used by setting the corresponding\n  `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n  This optimization is only available for plain matrices/vectors (rank-2/1\n  tensors) with datatypes `bfloat16` or `float32`.\n\n  For example:\n\n  ```python\n  # 2-D tensor `a`\n  # [[1, 2, 3],\n  #  [4, 5, 6]]\n  a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n  # 1-D tensor `b`\n  # [7, 9, 11]\n  b = tf.constant([7, 9, 11], shape=[3])\n\n  # `a` * `b`\n  # [ 58,  64]\n  c = tf.matvec(a, b)\n\n\n  # 3-D tensor `a`\n  # [[[ 1,  2,  3],\n  #   [ 4,  5,  6]],\n  #  [[ 7,  8,  9],\n  #   [10, 11, 12]]]\n  a = tf.constant(np.arange(1, 13, dtype=np.int32),\n                  shape=[2, 2, 3])\n\n  # 2-D tensor `b`\n  # [[13, 14, 15],\n  #  [16, 17, 18]]\n  b = tf.constant(np.arange(13, 19, dtype=np.int32),\n                  shape=[2, 3])\n\n  # `a` * `b`\n  # [[ 86, 212],\n  #  [410, 563]]\n  c = tf.matvec(a, b)\n  ```\n\n  Args:\n    a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n      `complex128` and rank > 1.\n    b: `Tensor` with same type and rank = `rank(a) - 1`.\n    transpose_a: If `True`, `a` is transposed before multiplication.\n    adjoint_a: If `True`, `a` is conjugated and transposed before\n      multiplication.\n    a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n    b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n    name: Name for the operation (optional).\n\n  Returns:\n    A `Tensor` of the same type as `a` and `b` where each inner-most vector is\n    the product of the corresponding matrices in `a` and vectors in `b`, e.g. if\n    all transpose or adjoint attributes are `False`:\n\n    `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i.\n\n    Note: This is matrix-vector product, not element-wise product.\n\n\n  Raises:\n    ValueError: If transpose_a and adjoint_a are both set to True.\n  '
    with ops.name_scope(name, 'MatVec', [a, b]) as name:
        output = matmul(a, array_ops.expand_dims(b, axis=(- 1)), transpose_a=transpose_a, adjoint_a=adjoint_a, a_is_sparse=a_is_sparse, b_is_sparse=b_is_sparse)
        return array_ops.squeeze(output, axis=(- 1))
Multiplies matrix `a` by vector `b`, producing `a` * `b`.

The matrix `a` must, following any transpositions, be a tensor of rank >= 2,
and we must have `shape(b) = shape(a)[:-2] + [shape(a)[-1]]`.

Both `a` and `b` must be of the same type. The supported types are:
`float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.

Matrix `a` can be transposed or adjointed (conjugated and transposed) on
the fly by setting one of the corresponding flag to `True`. These are `False`
by default.

If one or both of the inputs contain a lot of zeros, a more efficient
multiplication algorithm can be used by setting the corresponding
`a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.
This optimization is only available for plain matrices/vectors (rank-2/1
tensors) with datatypes `bfloat16` or `float32`.

For example:

```python
# 2-D tensor `a`
# [[1, 2, 3],
#  [4, 5, 6]]
a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])

# 1-D tensor `b`
# [7, 9, 11]
b = tf.constant([7, 9, 11], shape=[3])

# `a` * `b`
# [ 58,  64]
c = tf.matvec(a, b)


# 3-D tensor `a`
# [[[ 1,  2,  3],
#   [ 4,  5,  6]],
#  [[ 7,  8,  9],
#   [10, 11, 12]]]
a = tf.constant(np.arange(1, 13, dtype=np.int32),
                shape=[2, 2, 3])

# 2-D tensor `b`
# [[13, 14, 15],
#  [16, 17, 18]]
b = tf.constant(np.arange(13, 19, dtype=np.int32),
                shape=[2, 3])

# `a` * `b`
# [[ 86, 212],
#  [410, 563]]
c = tf.matvec(a, b)
```

Args:
  a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,
    `complex128` and rank > 1.
  b: `Tensor` with same type and rank = `rank(a) - 1`.
  transpose_a: If `True`, `a` is transposed before multiplication.
  adjoint_a: If `True`, `a` is conjugated and transposed before
    multiplication.
  a_is_sparse: If `True`, `a` is treated as a sparse matrix.
  b_is_sparse: If `True`, `b` is treated as a sparse matrix.
  name: Name for the operation (optional).

Returns:
  A `Tensor` of the same type as `a` and `b` where each inner-most vector is
  the product of the corresponding matrices in `a` and vectors in `b`, e.g. if
  all transpose or adjoint attributes are `False`:

  `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i.

  Note: This is matrix-vector product, not element-wise product.


Raises:
  ValueError: If transpose_a and adjoint_a are both set to True.
@tf_export('linalg.matvec')
def matvec(a, b, transpose_a=False, adjoint_a=False, a_is_sparse=False, b_is_sparse=False, name=None):
    'Multiplies matrix `a` by vector `b`, producing `a` * `b`.\n\n  The matrix `a` must, following any transpositions, be a tensor of rank >= 2,\n  and we must have `shape(b) = shape(a)[:-2] + [shape(a)[-1]]`.\n\n  Both `a` and `b` must be of the same type. The supported types are:\n  `float16`, `float32`, `float64`, `int32`, `complex64`, `complex128`.\n\n  Matrix `a` can be transposed or adjointed (conjugated and transposed) on\n  the fly by setting one of the corresponding flag to `True`. These are `False`\n  by default.\n\n  If one or both of the inputs contain a lot of zeros, a more efficient\n  multiplication algorithm can be used by setting the corresponding\n  `a_is_sparse` or `b_is_sparse` flag to `True`. These are `False` by default.\n  This optimization is only available for plain matrices/vectors (rank-2/1\n  tensors) with datatypes `bfloat16` or `float32`.\n\n  For example:\n\n  ```python\n  # 2-D tensor `a`\n  # [[1, 2, 3],\n  #  [4, 5, 6]]\n  a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])\n\n  # 1-D tensor `b`\n  # [7, 9, 11]\n  b = tf.constant([7, 9, 11], shape=[3])\n\n  # `a` * `b`\n  # [ 58,  64]\n  c = tf.matvec(a, b)\n\n\n  # 3-D tensor `a`\n  # [[[ 1,  2,  3],\n  #   [ 4,  5,  6]],\n  #  [[ 7,  8,  9],\n  #   [10, 11, 12]]]\n  a = tf.constant(np.arange(1, 13, dtype=np.int32),\n                  shape=[2, 2, 3])\n\n  # 2-D tensor `b`\n  # [[13, 14, 15],\n  #  [16, 17, 18]]\n  b = tf.constant(np.arange(13, 19, dtype=np.int32),\n                  shape=[2, 3])\n\n  # `a` * `b`\n  # [[ 86, 212],\n  #  [410, 563]]\n  c = tf.matvec(a, b)\n  ```\n\n  Args:\n    a: `Tensor` of type `float16`, `float32`, `float64`, `int32`, `complex64`,\n      `complex128` and rank > 1.\n    b: `Tensor` with same type and rank = `rank(a) - 1`.\n    transpose_a: If `True`, `a` is transposed before multiplication.\n    adjoint_a: If `True`, `a` is conjugated and transposed before\n      multiplication.\n    a_is_sparse: If `True`, `a` is treated as a sparse matrix.\n    b_is_sparse: If `True`, `b` is treated as a sparse matrix.\n    name: Name for the operation (optional).\n\n  Returns:\n    A `Tensor` of the same type as `a` and `b` where each inner-most vector is\n    the product of the corresponding matrices in `a` and vectors in `b`, e.g. if\n    all transpose or adjoint attributes are `False`:\n\n    `output`[..., i] = sum_k (`a`[..., i, k] * `b`[..., k]), for all indices i.\n\n    Note: This is matrix-vector product, not element-wise product.\n\n\n  Raises:\n    ValueError: If transpose_a and adjoint_a are both set to True.\n  '
    with ops.name_scope(name, 'MatVec', [a, b]) as name:
        output = matmul(a, array_ops.expand_dims(b, axis=(- 1)), transpose_a=transpose_a, adjoint_a=adjoint_a, a_is_sparse=a_is_sparse, b_is_sparse=b_is_sparse)
        return array_ops.squeeze(output, axis=(- 1))