def test_attribute_prefs(backend, fn, args):
if (backend is 'torch') and fn in (ar.real, ar.imag):
pytest.xfail("Pytorch doesn't support complex numbers yet...")
x = gen_rand((3, 5), backend)
y = fn(x, *args)
assert ar.infer_backend(x) == ar.infer_backend(y) == backend
def test_linalg_svd_square(backend):
if backend == 'sparse':
pytest.xfail("Sparse doesn't support linear algebra yet...")
x = gen_rand((5, 4), backend)
U, s, V = ar.do('linalg.svd', x)
assert (ar.infer_backend(x) == ar.infer_backend(U) == ar.infer_backend(s)
== ar.infer_backend(V) == backend)
y = U @ ar.do('diag', s, like=x) @ V
diff = ar.do('sum', abs(y - x))
assert ar.to_numpy(diff) < 1e-8
def get_interface(tensor):
"""Returns the name of the package that any array/tensor manipulations
will dispatch to. The returned strings correspond to those used for PennyLane
:doc:`interfaces </introduction/interfaces>`.
Args:
tensor (tensor_like): tensor input
Returns:
str: name of the interface
**Example**
>>> x = torch.tensor([1., 2.])
>>> get_interface(x)
'torch'
>>> from pennylane import numpy as np
>>> x = np.array([4, 5], requires_grad=True)
>>> get_interface(x)
'autograd'
"""
namespace = tensor.__class__.__module__.split(".")[0]
if namespace in ("pennylane", "autograd"):
return "autograd"
res = ar.infer_backend(tensor)
if res == "builtins":
return "numpy"
return res
def cast(tensor, dtype):
"""Casts the given tensor to a new type.
Args:
tensor (tensor_like): tensor to cast
dtype (str, np.dtype): Any supported NumPy dtype representation; this can be
a string (``"float64"``), a ``np.dtype`` object (``np.dtype("float64")``), or
a dtype class (``np.float64``). If ``tensor`` is not a NumPy array, the
**equivalent** dtype in the dispatched framework is used.
Returns:
tensor_like: a tensor with the same shape and values as ``tensor`` and the
same dtype as ``dtype``
**Example**
We can use NumPy dtype specifiers:
>>> x = torch.tensor([1, 2])
>>> cast(x, np.float64)
tensor([1., 2.], dtype=torch.float64)
We can also use strings:
>>> x = tf.Variable([1, 2])
>>> cast(x, "complex128")
<tf.Tensor: shape=(2,), dtype=complex128, numpy=array([1.+0.j, 2.+0.j])>
"""
if isinstance(tensor, (list, tuple)):
tensor = np.asarray(tensor)
if not isinstance(dtype, str):
try:
dtype = np.dtype(dtype).name
except (AttributeError, TypeError):
dtype = getattr(dtype, "name", dtype)
return ar.astype(tensor,
ar.to_backend_dtype(dtype, like=ar.infer_backend(tensor)))
def test_basic(backend, fn):
x = gen_rand((2, 3, 4), backend)
y = ar.do(fn, x)
if (backend == 'sparse') and (fn is 'sum'):
pytest.xfail("Sparse 'sum' outputs dense.")
assert ar.infer_backend(x) == ar.infer_backend(y) == backend
