def stack(values, axis=0):
"""Stack a sequence of tensors along the specified axis.
.. warning::
Tensors that are incompatible (such as Torch and TensorFlow tensors)
cannot both be present.
Args:
values (Sequence[tensor_like]): Sequence of tensor-like objects to
stack. Each object in the sequence must have the same size in the given axis.
axis (int): The axis along which the input tensors are stacked. ``axis=0`` corresponds
to vertical stacking.
Returns:
tensor_like: The stacked array. The stacked array will have one additional dimension
compared to the unstacked tensors.
**Example**
>>> x = tf.constant([0.6, 0.1, 0.6])
>>> y = tf.Variable([0.1, 0.2, 0.3])
>>> z = np.array([5., 8., 101.])
>>> stack([x, y, z])
<tf.Tensor: shape=(3, 3), dtype=float32, numpy=
array([[6.00e-01, 1.00e-01, 6.00e-01],
[1.00e-01, 2.00e-01, 3.00e-01],
[5.00e+00, 8.00e+00, 1.01e+02]], dtype=float32)>
"""
interface = _multi_dispatch(values)
values = np.coerce(values, like=interface)
return np.stack(values, axis=axis, like=interface)
def modified_gram_schmidt_np_mimic(X):
from autoray import numpy as np
print(np)
Q = []
for j in range(0, X.shape[0]):
q = X[j, :]
for i in range(0, j):
rij = np.tensordot(np.conj(Q[i]), q, 1)
q = q - rij * Q[i]
rjj = np.linalg.norm(q, 2)
Q.append(q / rjj)
return np.stack(Q, axis=0, like=X)
def diag(values, k=0):
"""Construct a diagonal tensor from a list of scalars.
Args:
values (tensor_like or Sequence[scalar]): sequence of numeric values that
make up the diagonal
k (int): The diagonal in question. ``k=0`` corresponds to the main diagonal.
Use ``k>0`` for diagonals above the main diagonal, and ``k<0`` for
diagonals below the main diagonal.
Returns:
tensor_like: the 2D diagonal tensor
**Example**
>>> x = [1., 2., tf.Variable(3.)]
>>> diag(x)
<tf.Tensor: shape=(3, 3), dtype=float32, numpy=
array([[1., 0., 0.],
[0., 2., 0.],
[0., 0., 3.]], dtype=float32)>
>>> y = tf.Variable([0.65, 0.2, 0.1])
>>> diag(y, k=-1)
<tf.Tensor: shape=(4, 4), dtype=float32, numpy=
array([[0. , 0. , 0. , 0. ],
[0.65, 0. , 0. , 0. ],
[0. , 0.2 , 0. , 0. ],
[0. , 0. , 0.1 , 0. ]], dtype=float32)>
>>> z = torch.tensor([0.1, 0.2])
>>> qml.math.diag(z, k=1)
tensor([[0.0000, 0.1000, 0.0000],
[0.0000, 0.0000, 0.2000],
[0.0000, 0.0000, 0.0000]])
"""
interface = _multi_dispatch(values)
if isinstance(values, (list, tuple)):
values = np.stack(np.coerce(values, like=interface), like=interface)
return np.diag(values, k=k, like=interface)
