def test_binary_op_scalarlist_fastpath(self, device, dtype, op):
for N in N_values:
for type_str, scalarlist in getScalarLists(N):
bool_int_div = op.ref == torch.div and dtype in integral_types_and(torch.bool)
disable_fastpath = bool_int_div
if type_str == "int":
disable_fastpath |= dtype == torch.bool
if type_str == "float":
disable_fastpath |= dtype in integral_types_and(torch.bool)
if type_str == "complex":
disable_fastpath |= dtype not in complex_types()
if type_str == "mixed":
disable_fastpath |= True and dtype not in complex_types()
self._test_binary_op_scalarlist(device, dtype, op, N, scalarlist, True, disable_fastpath)
def _test_unary(self, device, dtype, opinfo, N, is_fastpath):
op, ref, inplace_op, inplace_ref = self._get_funcs(opinfo, 1)
inputs = opinfo.sample_inputs(device, dtype, N, noncontiguous=not is_fastpath),
# note(mkozuki): Complex inputs for `_foreach_abs` go through slowpath.
if opinfo.name == "_foreach_abs" and dtype in complex_types():
is_fastpath = False
self._regular_unary_test(dtype, op, ref, inputs, is_fastpath)
self._inplace_unary_test(dtype, inplace_op, inplace_ref, inputs, is_fastpath)
def test_binary_op_scalar_fastpath(self, device, dtype, op):
for N, scalar in itertools.product(N_values, Scalars):
disable_fastpath = op.ref == torch.div and dtype in integral_types_and(torch.bool)
if isinstance(scalar, int):
disable_fastpath |= dtype == torch.bool
if isinstance(scalar, float):
disable_fastpath |= dtype in integral_types_and(torch.bool)
if isinstance(scalar, bool):
disable_fastpath |= dtype == torch.bool
if op.ref in (torch.add, torch.mul):
disable_fastpath = False
if isinstance(scalar, complex):
disable_fastpath |= dtype not in complex_types()
self._test_binary_op_scalar(device, dtype, op, N, scalar, True, disable_fastpath)
class TestComplexTensor(TestCase):
@dtypes(*complex_types())
def test_to_list(self, device, dtype):
# test that the complex float tensor has expected values and
# there's no garbage value in the resultant list
self.assertEqual(
torch.zeros((2, 2), device=device, dtype=dtype).tolist(),
[[0j, 0j], [0j, 0j]])
@dtypes(torch.float32, torch.float64)
def test_dtype_inference(self, device, dtype):
# issue: https://github.com/pytorch/pytorch/issues/36834
default_dtype = torch.get_default_dtype()
torch.set_default_dtype(dtype)
x = torch.tensor([3., 3. + 5.j], device=device)
torch.set_default_dtype(default_dtype)
self.assertEqual(
x.dtype, torch.cdouble if dtype == torch.float64 else torch.cfloat)
DecorateInfo(
unittest.expectedFailure, "TestJit", "test_variant_consistency_jit"
),
DecorateInfo(
unittest.skip("Failing on some jobs"),
"TestReductions",
"test_reference_masked",
dtypes=(torch.bool, torch.int8, torch.int16, torch.int32),
),
# FIXME: "cuda_scatter_gather_base_kernel_func" not implemented for ... (used for sparse_coo inputs)
DecorateInfo(
unittest.skip("Skipped!"),
"TestMasked",
"test_mask_layout",
device_type="cuda",
dtypes=(torch.bool, *integral_types(), *complex_types()),
),
),
decorators=[
DecorateInfo(
toleranceOverride({torch.float16: tol(atol=1e-03, rtol=1e-02)}),
"TestReductions",
"test_reference_masked",
),
DecorateInfo(
toleranceOverride({torch.float16: tol(atol=1e-03, rtol=1e-03)}),
"TestReductions",
"test_ref_duplicate_values",
),
],
sample_inputs_func=sample_inputs_masked_reduction,