library
stringclasses
1 value
test_file
stringclasses
785 values
test_function
stringlengths
1
295
before
stringlengths
0
448k
after
stringlengths
0
487k
context_before
stringclasses
947 values
context_after
stringlengths
0
16.3k
commit_before
stringclasses
1 value
commit_after
stringclasses
1 value
change_type
stringclasses
3 values
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_infinite
def test_infinite(self): assert_raises( (RuntimeError, ValueError), np.arange, 0, np.inf # "unsupported range", )
import builtins import collections.abc import ctypes import functools import io import itertools import mmap import operator import os import sys import tempfile import warnings import weakref from contextlib import contextmanager from decimal import Decimal from pathlib import Path from tempfile import mkstemp from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest import numpy import pytest from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, slowTest as slow, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) import torch._numpy as np from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) skip = functools.partial(skipif, True) IS_PYPY = False IS_PYSTON = False HAS_REFCOUNT = True from numpy.core.tests._locales import CommaDecimalPointLocale from numpy.testing._private.utils import _no_tracing, requires_memory np.asanyarray = np.asarray np.asfortranarray = np.asarray import pickle from numpy.core.numeric import set_string_function _sctypes = { "int": [np.int8, np.int16, np.int32, np.int64], "uint": [np.uint8, np.uint16, np.uint32, np.uint64], "float": [np.float32, np.float64], "complex": [np.complex64, np.complex128] # no complex256 in torch._numpy + ([np.clongdouble] if hasattr(np, "clongdouble") else []), } from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator NEIGH_MODE = {"zero": 0, "one": 1, "constant": 2, "circular": 3, "mirror": 4} from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY @instantiate_parametrized_tests class TestArange(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_nan_step
def test_nan_step(self): assert_raises( (RuntimeError, ValueError), # "cannot compute length", np.arange, 0, 1, np.nan, )
import builtins import collections.abc import ctypes import functools import io import itertools import mmap import operator import os import sys import tempfile import warnings import weakref from contextlib import contextmanager from decimal import Decimal from pathlib import Path from tempfile import mkstemp from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest import numpy import pytest from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, slowTest as slow, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) import torch._numpy as np from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) skip = functools.partial(skipif, True) IS_PYPY = False IS_PYSTON = False HAS_REFCOUNT = True from numpy.core.tests._locales import CommaDecimalPointLocale from numpy.testing._private.utils import _no_tracing, requires_memory np.asanyarray = np.asarray np.asfortranarray = np.asarray import pickle from numpy.core.numeric import set_string_function _sctypes = { "int": [np.int8, np.int16, np.int32, np.int64], "uint": [np.uint8, np.uint16, np.uint32, np.uint64], "float": [np.float32, np.float64], "complex": [np.complex64, np.complex128] # no complex256 in torch._numpy + ([np.clongdouble] if hasattr(np, "clongdouble") else []), } from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator NEIGH_MODE = {"zero": 0, "one": 1, "constant": 2, "circular": 3, "mirror": 4} from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY @instantiate_parametrized_tests class TestArange(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_zero_step
def test_zero_step(self): assert_raises(ZeroDivisionError, np.arange, 0, 10, 0) assert_raises(ZeroDivisionError, np.arange, 0.0, 10.0, 0.0) # empty range assert_raises(ZeroDivisionError, np.arange, 0, 0, 0) assert_raises(ZeroDivisionError, np.arange, 0.0, 0.0, 0.0)
import builtins import collections.abc import ctypes import functools import io import itertools import mmap import operator import os import sys import tempfile import warnings import weakref from contextlib import contextmanager from decimal import Decimal from pathlib import Path from tempfile import mkstemp from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest import numpy import pytest from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, slowTest as slow, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) import torch._numpy as np from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) skip = functools.partial(skipif, True) IS_PYPY = False IS_PYSTON = False HAS_REFCOUNT = True from numpy.core.tests._locales import CommaDecimalPointLocale from numpy.testing._private.utils import _no_tracing, requires_memory np.asanyarray = np.asarray np.asfortranarray = np.asarray import pickle from numpy.core.numeric import set_string_function _sctypes = { "int": [np.int8, np.int16, np.int32, np.int64], "uint": [np.uint8, np.uint16, np.uint32, np.uint64], "float": [np.float32, np.float64], "complex": [np.complex64, np.complex128] # no complex256 in torch._numpy + ([np.clongdouble] if hasattr(np, "clongdouble") else []), } from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator NEIGH_MODE = {"zero": 0, "one": 1, "constant": 2, "circular": 3, "mirror": 4} from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY @instantiate_parametrized_tests class TestArange(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_require_range_2
def test_require_range_2(self): assert_raises(TypeError, np.arange, start=4)
import builtins import collections.abc import ctypes import functools import io import itertools import mmap import operator import os import sys import tempfile import warnings import weakref from contextlib import contextmanager from decimal import Decimal from pathlib import Path from tempfile import mkstemp from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest import numpy import pytest from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, slowTest as slow, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) import torch._numpy as np from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) skip = functools.partial(skipif, True) IS_PYPY = False IS_PYSTON = False HAS_REFCOUNT = True from numpy.core.tests._locales import CommaDecimalPointLocale from numpy.testing._private.utils import _no_tracing, requires_memory np.asanyarray = np.asarray np.asfortranarray = np.asarray import pickle from numpy.core.numeric import set_string_function _sctypes = { "int": [np.int8, np.int16, np.int32, np.int64], "uint": [np.uint8, np.uint16, np.uint32, np.uint64], "float": [np.float32, np.float64], "complex": [np.complex64, np.complex128] # no complex256 in torch._numpy + ([np.clongdouble] if hasattr(np, "clongdouble") else []), } from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator NEIGH_MODE = {"zero": 0, "one": 1, "constant": 2, "circular": 3, "mirror": 4} from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY @instantiate_parametrized_tests class TestArange(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_cumproduct
def test_cumproduct(self): A = [[1, 2, 3], [4, 5, 6]] assert_(np.all(np.cumprod(A) == np.array([1, 2, 6, 24, 120, 720])))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_diagonal
def test_diagonal(self): a = [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]] out = np.diagonal(a) tgt = [0, 5, 10] assert_equal(out, tgt)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_mean
def test_mean(self): A = [[1, 2, 3], [4, 5, 6]] assert_(np.mean(A) == 3.5) assert_(np.all(np.mean(A, 0) == np.array([2.5, 3.5, 4.5]))) assert_(np.all(np.mean(A, 1) == np.array([2.0, 5.0]))) # with warnings.catch_warnings(record=True) as w: # warnings.filterwarnings('always', '', RuntimeWarning) assert_(np.isnan(np.mean([]))) # assert_(w[0].category is RuntimeWarning)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_ptp
def test_ptp(self): a = [3, 4, 5, 10, -3, -5, 6.0] assert_equal(np.ptp(a, axis=0), 15.0)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_prod
def test_prod(self): arr = [[1, 2, 3, 4], [5, 6, 7, 9], [10, 3, 4, 5]] tgt = [24, 1890, 600] assert_equal(np.prod(arr, axis=-1), tgt)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_ravel
def test_ravel(self): a = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]] tgt = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] assert_equal(np.ravel(a), tgt)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_repeat
def test_repeat(self): a = [1, 2, 3] tgt = [1, 1, 2, 2, 3, 3] out = np.repeat(a, 2) assert_equal(out, tgt)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_reshape
def test_reshape(self): arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]] tgt = [[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]] assert_equal(np.reshape(arr, (2, 6)), tgt)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_round
def test_round(self): arr = [1.56, 72.54, 6.35, 3.25] tgt = [1.6, 72.5, 6.4, 3.2] assert_equal(np.around(arr, decimals=1), tgt) s = np.float64(1.0) assert_equal(s.round(), 1.0)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_explicit_dtype
def test_explicit_dtype(self, dt): assert np.arange(5.0, dtype=dt).dtype == dt
import builtins import collections.abc import ctypes import functools import io import itertools import mmap import operator import os import sys import tempfile import warnings import weakref from contextlib import contextmanager from decimal import Decimal from pathlib import Path from tempfile import mkstemp from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest import numpy import pytest from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, slowTest as slow, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) import torch._numpy as np from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) skip = functools.partial(skipif, True) IS_PYPY = False IS_PYSTON = False HAS_REFCOUNT = True from numpy.core.tests._locales import CommaDecimalPointLocale from numpy.testing._private.utils import _no_tracing, requires_memory np.asanyarray = np.asarray np.asfortranarray = np.asarray import pickle from numpy.core.numeric import set_string_function _sctypes = { "int": [np.int8, np.int16, np.int32, np.int64], "uint": [np.uint8, np.uint16, np.uint32, np.uint64], "float": [np.float32, np.float64], "complex": [np.complex64, np.complex128] # no complex256 in torch._numpy + ([np.clongdouble] if hasattr(np, "clongdouble") else []), } from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator NEIGH_MODE = {"zero": 0, "one": 1, "constant": 2, "circular": 3, "mirror": 4} from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY @instantiate_parametrized_tests class TestArange(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_richcompare_scalar_boolean_singleton_return
def test_richcompare_scalar_boolean_singleton_return(self): # These are currently guaranteed to be the boolean singletons, but maybe # returning NumPy booleans would also be OK: assert (np.array(0) == "a") is False assert (np.array(0) != "a") is True assert (np.int16(0) == "a") is False assert (np.int16(0) != "a") is True
import builtins import collections.abc import ctypes import functools import io import itertools import mmap import operator import os import sys import tempfile import warnings import weakref from contextlib import contextmanager from decimal import Decimal from pathlib import Path from tempfile import mkstemp from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest import numpy import pytest from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, slowTest as slow, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) import torch._numpy as np from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) skip = functools.partial(skipif, True) IS_PYPY = False IS_PYSTON = False HAS_REFCOUNT = True from numpy.core.tests._locales import CommaDecimalPointLocale from numpy.testing._private.utils import _no_tracing, requires_memory np.asanyarray = np.asarray np.asfortranarray = np.asarray import pickle from numpy.core.numeric import set_string_function _sctypes = { "int": [np.int8, np.int16, np.int32, np.int64], "uint": [np.uint8, np.uint16, np.uint32, np.uint64], "float": [np.float32, np.float64], "complex": [np.complex64, np.complex128] # no complex256 in torch._numpy + ([np.clongdouble] if hasattr(np, "clongdouble") else []), } from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator NEIGH_MODE = {"zero": 0, "one": 1, "constant": 2, "circular": 3, "mirror": 4} from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY class TestRichcompareScalar(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_smaller_dtype_multiple
def test_smaller_dtype_multiple(self): # x is non-contiguous x = np.arange(10, dtype="<i4")[::2] with pytest.raises(ValueError, match="the last axis must be contiguous"): x.view("<i2") expected = [[0, 0], [2, 0], [4, 0], [6, 0], [8, 0]] assert_array_equal(x[:, np.newaxis].view("<i2"), expected)
import builtins import collections.abc import ctypes import functools import io import itertools import mmap import operator import os import sys import tempfile import warnings import weakref from contextlib import contextmanager from decimal import Decimal from pathlib import Path from tempfile import mkstemp from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest import numpy import pytest from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, slowTest as slow, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) import torch._numpy as np from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) skip = functools.partial(skipif, True) IS_PYPY = False IS_PYSTON = False HAS_REFCOUNT = True from numpy.core.tests._locales import CommaDecimalPointLocale from numpy.testing._private.utils import _no_tracing, requires_memory np.asanyarray = np.asarray np.asfortranarray = np.asarray import pickle from numpy.core.numeric import set_string_function _sctypes = { "int": [np.int8, np.int16, np.int32, np.int64], "uint": [np.uint8, np.uint16, np.uint32, np.uint64], "float": [np.float32, np.float64], "complex": [np.complex64, np.complex128] # no complex256 in torch._numpy + ([np.clongdouble] if hasattr(np, "clongdouble") else []), } from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator NEIGH_MODE = {"zero": 0, "one": 1, "constant": 2, "circular": 3, "mirror": 4} from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY @skip # (reason="implement views/dtypes") class TestViewDtype(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_smaller_dtype_not_multiple
def test_smaller_dtype_not_multiple(self): # x is non-contiguous x = np.arange(5, dtype="<i4")[::2] with pytest.raises(ValueError, match="the last axis must be contiguous"): x.view("S3") with pytest.raises(ValueError, match="When changing to a smaller dtype"): x[:, np.newaxis].view("S3") # Make sure the problem is because of the dtype size expected = [[b""], [b"\x02"], [b"\x04"]] assert_array_equal(x[:, np.newaxis].view("S4"), expected)
import builtins import collections.abc import ctypes import functools import io import itertools import mmap import operator import os import sys import tempfile import warnings import weakref from contextlib import contextmanager from decimal import Decimal from pathlib import Path from tempfile import mkstemp from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest import numpy import pytest from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, slowTest as slow, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) import torch._numpy as np from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) skip = functools.partial(skipif, True) IS_PYPY = False IS_PYSTON = False HAS_REFCOUNT = True from numpy.core.tests._locales import CommaDecimalPointLocale from numpy.testing._private.utils import _no_tracing, requires_memory np.asanyarray = np.asarray np.asfortranarray = np.asarray import pickle from numpy.core.numeric import set_string_function _sctypes = { "int": [np.int8, np.int16, np.int32, np.int64], "uint": [np.uint8, np.uint16, np.uint32, np.uint64], "float": [np.float32, np.float64], "complex": [np.complex64, np.complex128] # no complex256 in torch._numpy + ([np.clongdouble] if hasattr(np, "clongdouble") else []), } from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator NEIGH_MODE = {"zero": 0, "one": 1, "constant": 2, "circular": 3, "mirror": 4} from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY @skip # (reason="implement views/dtypes") class TestViewDtype(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_larger_dtype_multiple
def test_larger_dtype_multiple(self): # x is non-contiguous in the first dimension, contiguous in the last x = np.arange(20, dtype="<i2").reshape(10, 2)[::2, :] expected = np.array( [[65536], [327684], [589832], [851980], [1114128]], dtype="<i4" ) assert_array_equal(x.view("<i4"), expected)
import builtins import collections.abc import ctypes import functools import io import itertools import mmap import operator import os import sys import tempfile import warnings import weakref from contextlib import contextmanager from decimal import Decimal from pathlib import Path from tempfile import mkstemp from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest import numpy import pytest from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, slowTest as slow, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) import torch._numpy as np from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) skip = functools.partial(skipif, True) IS_PYPY = False IS_PYSTON = False HAS_REFCOUNT = True from numpy.core.tests._locales import CommaDecimalPointLocale from numpy.testing._private.utils import _no_tracing, requires_memory np.asanyarray = np.asarray np.asfortranarray = np.asarray import pickle from numpy.core.numeric import set_string_function _sctypes = { "int": [np.int8, np.int16, np.int32, np.int64], "uint": [np.uint8, np.uint16, np.uint32, np.uint64], "float": [np.float32, np.float64], "complex": [np.complex64, np.complex128] # no complex256 in torch._numpy + ([np.clongdouble] if hasattr(np, "clongdouble") else []), } from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator NEIGH_MODE = {"zero": 0, "one": 1, "constant": 2, "circular": 3, "mirror": 4} from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY @skip # (reason="implement views/dtypes") class TestViewDtype(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_larger_dtype_not_multiple
def test_larger_dtype_not_multiple(self): # x is non-contiguous in the first dimension, contiguous in the last x = np.arange(20, dtype="<i2").reshape(10, 2)[::2, :] with pytest.raises(ValueError, match="When changing to a larger dtype"): x.view("S3") # Make sure the problem is because of the dtype size expected = [ [b"\x00\x00\x01"], [b"\x04\x00\x05"], [b"\x08\x00\t"], [b"\x0c\x00\r"], [b"\x10\x00\x11"], ] assert_array_equal(x.view("S4"), expected)
import builtins import collections.abc import ctypes import functools import io import itertools import mmap import operator import os import sys import tempfile import warnings import weakref from contextlib import contextmanager from decimal import Decimal from pathlib import Path from tempfile import mkstemp from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest import numpy import pytest from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, slowTest as slow, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) import torch._numpy as np from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) skip = functools.partial(skipif, True) IS_PYPY = False IS_PYSTON = False HAS_REFCOUNT = True from numpy.core.tests._locales import CommaDecimalPointLocale from numpy.testing._private.utils import _no_tracing, requires_memory np.asanyarray = np.asarray np.asfortranarray = np.asarray import pickle from numpy.core.numeric import set_string_function _sctypes = { "int": [np.int8, np.int16, np.int32, np.int64], "uint": [np.uint8, np.uint16, np.uint32, np.uint64], "float": [np.float32, np.float64], "complex": [np.complex64, np.complex128] # no complex256 in torch._numpy + ([np.clongdouble] if hasattr(np, "clongdouble") else []), } from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator NEIGH_MODE = {"zero": 0, "one": 1, "constant": 2, "circular": 3, "mirror": 4} from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY @skip # (reason="implement views/dtypes") class TestViewDtype(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_f_contiguous
def test_f_contiguous(self): # x is F-contiguous x = np.arange(4 * 3, dtype="<i4").reshape(4, 3).T with pytest.raises(ValueError, match="the last axis must be contiguous"): x.view("<i2")
import builtins import collections.abc import ctypes import functools import io import itertools import mmap import operator import os import sys import tempfile import warnings import weakref from contextlib import contextmanager from decimal import Decimal from pathlib import Path from tempfile import mkstemp from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest import numpy import pytest from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, slowTest as slow, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) import torch._numpy as np from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) skip = functools.partial(skipif, True) IS_PYPY = False IS_PYSTON = False HAS_REFCOUNT = True from numpy.core.tests._locales import CommaDecimalPointLocale from numpy.testing._private.utils import _no_tracing, requires_memory np.asanyarray = np.asarray np.asfortranarray = np.asarray import pickle from numpy.core.numeric import set_string_function _sctypes = { "int": [np.int8, np.int16, np.int32, np.int64], "uint": [np.uint8, np.uint16, np.uint32, np.uint64], "float": [np.float32, np.float64], "complex": [np.complex64, np.complex128] # no complex256 in torch._numpy + ([np.clongdouble] if hasattr(np, "clongdouble") else []), } from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator NEIGH_MODE = {"zero": 0, "one": 1, "constant": 2, "circular": 3, "mirror": 4} from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY @skip # (reason="implement views/dtypes") class TestViewDtype(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_non_c_contiguous
def test_non_c_contiguous(self): # x is contiguous in axis=-1, but not C-contiguous in other axes x = np.arange(2 * 3 * 4, dtype="i1").reshape(2, 3, 4).transpose(1, 0, 2) expected = [ [[256, 770], [3340, 3854]], [[1284, 1798], [4368, 4882]], [[2312, 2826], [5396, 5910]], ] assert_array_equal(x.view("<i2"), expected)
import builtins import collections.abc import ctypes import functools import io import itertools import mmap import operator import os import sys import tempfile import warnings import weakref from contextlib import contextmanager from decimal import Decimal from pathlib import Path from tempfile import mkstemp from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest import numpy import pytest from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, slowTest as slow, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) import torch._numpy as np from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) skip = functools.partial(skipif, True) IS_PYPY = False IS_PYSTON = False HAS_REFCOUNT = True from numpy.core.tests._locales import CommaDecimalPointLocale from numpy.testing._private.utils import _no_tracing, requires_memory np.asanyarray = np.asarray np.asfortranarray = np.asarray import pickle from numpy.core.numeric import set_string_function _sctypes = { "int": [np.int8, np.int16, np.int32, np.int64], "uint": [np.uint8, np.uint16, np.uint32, np.uint64], "float": [np.float32, np.float64], "complex": [np.complex64, np.complex128] # no complex256 in torch._numpy + ([np.clongdouble] if hasattr(np, "clongdouble") else []), } from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator NEIGH_MODE = {"zero": 0, "one": 1, "constant": 2, "circular": 3, "mirror": 4} from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY @skip # (reason="implement views/dtypes") class TestViewDtype(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_sort_float
def test_sort_float(self, N): # Regular data with nan sprinkled np.random.seed(42) arr = -0.5 + np.random.sample(N).astype("f") arr[np.random.choice(arr.shape[0], 3)] = np.nan assert_equal(np.sort(arr, kind="quick"), np.sort(arr, kind="heap")) # (2) with +INF infarr = np.inf * np.ones(N, dtype="f") infarr[np.random.choice(infarr.shape[0], 5)] = -1.0 assert_equal(np.sort(infarr, kind="quick"), np.sort(infarr, kind="heap")) # (3) with -INF neginfarr = -np.inf * np.ones(N, dtype="f") neginfarr[np.random.choice(neginfarr.shape[0], 5)] = 1.0 assert_equal(np.sort(neginfarr, kind="quick"), np.sort(neginfarr, kind="heap")) # (4) with +/-INF infarr = np.inf * np.ones(N, dtype="f") infarr[np.random.choice(infarr.shape[0], (int)(N / 2))] = -np.inf assert_equal(np.sort(infarr, kind="quick"), np.sort(infarr, kind="heap"))
import builtins import collections.abc import ctypes import functools import io import itertools import mmap import operator import os import sys import tempfile import warnings import weakref from contextlib import contextmanager from decimal import Decimal from pathlib import Path from tempfile import mkstemp from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest import numpy import pytest from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, slowTest as slow, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) import torch._numpy as np from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) skip = functools.partial(skipif, True) IS_PYPY = False IS_PYSTON = False HAS_REFCOUNT = True from numpy.core.tests._locales import CommaDecimalPointLocale from numpy.testing._private.utils import _no_tracing, requires_memory np.asanyarray = np.asarray np.asfortranarray = np.asarray import pickle from numpy.core.numeric import set_string_function _sctypes = { "int": [np.int8, np.int16, np.int32, np.int64], "uint": [np.uint8, np.uint16, np.uint32, np.uint64], "float": [np.float32, np.float64], "complex": [np.complex64, np.complex128] # no complex256 in torch._numpy + ([np.clongdouble] if hasattr(np, "clongdouble") else []), } from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator NEIGH_MODE = {"zero": 0, "one": 1, "constant": 2, "circular": 3, "mirror": 4} from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY @instantiate_parametrized_tests class TestSortFloatMisc(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_sort_int
def test_sort_int(self): # Random data with NPY_MAX_INT32 and NPY_MIN_INT32 sprinkled # rng = np.random.default_rng(42) np.random.seed(1234) N = 2047 minv = np.iinfo(np.int32).min maxv = np.iinfo(np.int32).max arr = np.random.randint(low=minv, high=maxv, size=N).astype("int32") arr[np.random.choice(arr.shape[0], 10)] = minv arr[np.random.choice(arr.shape[0], 10)] = maxv assert_equal(np.sort(arr, kind="quick"), np.sort(arr, kind="heap"))
import builtins import collections.abc import ctypes import functools import io import itertools import mmap import operator import os import sys import tempfile import warnings import weakref from contextlib import contextmanager from decimal import Decimal from pathlib import Path from tempfile import mkstemp from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest import numpy import pytest from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, slowTest as slow, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) import torch._numpy as np from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_array_less, assert_equal, assert_raises_regex, assert_warns, suppress_warnings, ) skip = functools.partial(skipif, True) IS_PYPY = False IS_PYSTON = False HAS_REFCOUNT = True from numpy.core.tests._locales import CommaDecimalPointLocale from numpy.testing._private.utils import _no_tracing, requires_memory np.asanyarray = np.asarray np.asfortranarray = np.asarray import pickle from numpy.core.numeric import set_string_function _sctypes = { "int": [np.int8, np.int16, np.int32, np.int64], "uint": [np.uint8, np.uint16, np.uint32, np.uint64], "float": [np.float32, np.float64], "complex": [np.complex64, np.complex128] # no complex256 in torch._numpy + ([np.clongdouble] if hasattr(np, "clongdouble") else []), } from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator NEIGH_MODE = {"zero": 0, "one": 1, "constant": 2, "circular": 3, "mirror": 4} from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY @instantiate_parametrized_tests class TestSortFloatMisc(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_copies
def test_copies(self): A = np.array([[1, 2], [3, 4]]) Ar1 = np.array([[1, 2, 3, 4], [1, 2, 3, 4]]) assert_equal(np.resize(A, (2, 4)), Ar1) Ar2 = np.array([[1, 2], [3, 4], [1, 2], [3, 4]]) assert_equal(np.resize(A, (4, 2)), Ar2) Ar3 = np.array([[1, 2, 3], [4, 1, 2], [3, 4, 1], [2, 3, 4]]) assert_equal(np.resize(A, (4, 3)), Ar3)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestResize(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_repeats
def test_repeats(self): A = np.array([1, 2, 3]) Ar1 = np.array([[1, 2, 3, 1], [2, 3, 1, 2]]) assert_equal(np.resize(A, (2, 4)), Ar1) Ar2 = np.array([[1, 2], [3, 1], [2, 3], [1, 2]]) assert_equal(np.resize(A, (4, 2)), Ar2) Ar3 = np.array([[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]]) assert_equal(np.resize(A, (4, 3)), Ar3)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestResize(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_zeroresize
def test_zeroresize(self): A = np.array([[1, 2], [3, 4]]) Ar = np.resize(A, (0,)) assert_array_equal(Ar, np.array([])) assert_equal(A.dtype, Ar.dtype) Ar = np.resize(A, (0, 2)) assert_equal(Ar.shape, (0, 2)) Ar = np.resize(A, (2, 0)) assert_equal(Ar.shape, (2, 0))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestResize(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_reshape_from_zero
def test_reshape_from_zero(self): # See also gh-6740 A = np.zeros(0, dtype=np.float32) Ar = np.resize(A, (2, 1)) assert_array_equal(Ar, np.zeros((2, 1), Ar.dtype)) assert_equal(A.dtype, Ar.dtype)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestResize(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_negative_resize
def test_negative_resize(self): A = np.arange(0, 10, dtype=np.float32) new_shape = (-10, -1) with pytest.raises((RuntimeError, ValueError)): np.resize(A, new_shape=new_shape)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestResize(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_choose
def test_choose(self): choices = [[0, 1, 2], [3, 4, 5], [5, 6, 7]] tgt = [5, 1, 5] a = [2, 0, 1] out = np.choose(a, choices) assert_equal(out, tgt)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_compress
def test_compress(self): arr = [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]] tgt = [[5, 6, 7, 8, 9]] out = np.compress([0, 1], arr, axis=0) assert_equal(out, tgt)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_count_nonzero
def test_count_nonzero(self): arr = [[0, 1, 7, 0, 0], [3, 0, 0, 2, 19]] tgt = np.array([2, 3]) out = np.count_nonzero(arr, axis=1) assert_equal(out, tgt)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_take
def test_take(self): tgt = [2, 3, 5] indices = [1, 2, 4] a = [1, 2, 3, 4, 5] out = np.take(a, indices) assert_equal(out, tgt)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_trace
def test_trace(self): c = [[1, 2], [3, 4], [5, 6]] assert_equal(np.trace(c), 5)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_transpose
def test_transpose(self): arr = [[1, 2], [3, 4], [5, 6]] tgt = [[1, 3, 5], [2, 4, 6]] assert_equal(np.transpose(arr, (1, 0)), tgt)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_var
def test_var(self): A = [[1, 2, 3], [4, 5, 6]] assert_almost_equal(np.var(A), 2.9166666666666665) assert_almost_equal(np.var(A, 0), np.array([2.25, 2.25, 2.25])) assert_almost_equal(np.var(A, 1), np.array([0.66666667, 0.66666667])) # with warnings.catch_warnings(record=True) as w: # warnings.filterwarnings('always', '', RuntimeWarning) assert_(np.isnan(np.var([]))) # assert_(w[0].category is RuntimeWarning)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_isscalar
def test_isscalar(self): assert_(np.isscalar(3.1)) assert_(np.isscalar(np.int16(12345))) assert_(np.isscalar(False)) assert_(np.isscalar("numpy")) assert_(not np.isscalar([3.1])) assert_(not np.isscalar(None)) # PEP 3141 from fractions import Fraction assert_(np.isscalar(Fraction(5, 17))) from numbers import Number assert_(np.isscalar(Number()))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @xfail # (reason="TODO") class TestIsscalar(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_logical
def test_logical(self): f = np.False_ t = np.True_ s = "xyz" assert_((t and s) is s) assert_((f and s) is f)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestBoolScalar(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_bitwise_or_eq
def test_bitwise_or_eq(self): f = np.False_ t = np.True_ assert_((t | t) == t) assert_((f | t) == t) assert_((t | f) == t) assert_((f | f) == f)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestBoolScalar(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_bitwise_or_is
def test_bitwise_or_is(self): f = np.False_ t = np.True_ assert_(bool(t | t) is bool(t)) assert_(bool(f | t) is bool(t)) assert_(bool(t | f) is bool(t)) assert_(bool(f | f) is bool(f))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestBoolScalar(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_bitwise_and_eq
def test_bitwise_and_eq(self): f = np.False_ t = np.True_ assert_((t & t) == t) assert_((f & t) == f) assert_((t & f) == f) assert_((f & f) == f)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestBoolScalar(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_bitwise_and_is
def test_bitwise_and_is(self): f = np.False_ t = np.True_ assert_(bool(t & t) is bool(t)) assert_(bool(f & t) is bool(f)) assert_(bool(t & f) is bool(f)) assert_(bool(f & f) is bool(f))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestBoolScalar(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_round_py_consistency
def test_round_py_consistency(self): f = 5.1 * 10**73 assert_equal(round(np.float64(f), -73), round(f, -73))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_searchsorted
def test_searchsorted(self): arr = [-8, -5, -1, 3, 6, 10] out = np.searchsorted(arr, 0) assert_equal(out, 3)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_size
def test_size(self): A = [[1, 2, 3], [4, 5, 6]] assert_(np.size(A) == 6) assert_(np.size(A, 0) == 2) assert_(np.size(A, 1) == 3)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_squeeze
def test_squeeze(self): A = [[[1, 1, 1], [2, 2, 2], [3, 3, 3]]] assert_equal(np.squeeze(A).shape, (3, 3)) assert_equal(np.squeeze(np.zeros((1, 3, 1))).shape, (3,)) assert_equal(np.squeeze(np.zeros((1, 3, 1)), axis=0).shape, (3, 1)) assert_equal(np.squeeze(np.zeros((1, 3, 1)), axis=-1).shape, (1, 3)) assert_equal(np.squeeze(np.zeros((1, 3, 1)), axis=2).shape, (1, 3)) assert_equal(np.squeeze([np.zeros((3, 1))]).shape, (3,)) assert_equal(np.squeeze([np.zeros((3, 1))], axis=0).shape, (3, 1)) assert_equal(np.squeeze([np.zeros((3, 1))], axis=2).shape, (1, 3)) assert_equal(np.squeeze([np.zeros((3, 1))], axis=-1).shape, (1, 3))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_std
def test_std(self): A = [[1, 2, 3], [4, 5, 6]] assert_almost_equal(np.std(A), 1.707825127659933) assert_almost_equal(np.std(A, 0), np.array([1.5, 1.5, 1.5])) assert_almost_equal(np.std(A, 1), np.array([0.81649658, 0.81649658])) # with warnings.catch_warnings(record=True) as w: # warnings.filterwarnings('always', '', RuntimeWarning) assert_(np.isnan(np.std([]))) # assert_(w[0].category is RuntimeWarning)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_swapaxes
def test_swapaxes(self): tgt = [[[0, 4], [2, 6]], [[1, 5], [3, 7]]] a = [[[0, 1], [2, 3]], [[4, 5], [6, 7]]] out = np.swapaxes(a, 0, 2) assert_equal(out, tgt)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_sum
def test_sum(self): m = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] tgt = [[6], [15], [24]] out = np.sum(m, axis=1, keepdims=True) assert_equal(tgt, out)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) @instantiate_parametrized_tests class TestNonarrayArgs(TestCase): from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_bitwise_xor_eq
def test_bitwise_xor_eq(self): f = np.False_ t = np.True_ assert_((t ^ t) == f) assert_((f ^ t) == t) assert_((t ^ f) == t) assert_((f ^ f) == f)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestBoolScalar(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_bitwise_xor_is
def test_bitwise_xor_is(self): f = np.False_ t = np.True_ assert_(bool(t ^ t) is bool(f)) assert_(bool(f ^ t) is bool(t)) assert_(bool(t ^ f) is bool(t)) assert_(bool(f ^ f) is bool(f))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestBoolScalar(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
setUp
def setUp(self): super().setUp() # offset for simd tests self.t = np.array([True] * 41, dtype=bool)[1::] self.f = np.array([False] * 41, dtype=bool)[1::] self.o = np.array([False] * 42, dtype=bool)[2::] self.nm = self.f.copy() self.im = self.t.copy() self.nm[3] = True self.nm[-2] = True self.im[3] = False self.im[-2] = False
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestBoolArray(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_all_any
def test_all_any(self): assert_(self.t.all()) assert_(self.t.any()) assert_(not self.f.all()) assert_(not self.f.any()) assert_(self.nm.any()) assert_(self.im.any()) assert_(not self.nm.all()) assert_(not self.im.all()) # check bad element in all positions for i in range(256 - 7): d = np.array([False] * 256, dtype=bool)[7::] d[i] = True assert_(np.any(d)) e = np.array([True] * 256, dtype=bool)[7::] e[i] = False assert_(not np.all(e)) assert_array_equal(e, ~d) # big array test for blocked libc loops for i in list(range(9, 6000, 507)) + [7764, 90021, -10]: d = np.array([False] * 100043, dtype=bool) d[i] = True assert_(np.any(d), msg=f"{i!r}") e = np.array([True] * 100043, dtype=bool) e[i] = False assert_(not np.all(e), msg=f"{i!r}")
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestBoolArray(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_logical_not_abs
def test_logical_not_abs(self): assert_array_equal(~self.t, self.f) assert_array_equal(np.abs(~self.t), self.f) assert_array_equal(np.abs(~self.f), self.t) assert_array_equal(np.abs(self.f), self.f) assert_array_equal(~np.abs(self.f), self.t) assert_array_equal(~np.abs(self.t), self.f) assert_array_equal(np.abs(~self.nm), self.im) np.logical_not(self.t, out=self.o) assert_array_equal(self.o, self.f) np.abs(self.t, out=self.o) assert_array_equal(self.o, self.t)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestBoolArray(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_logical_and_or_xor
def test_logical_and_or_xor(self): assert_array_equal(self.t | self.t, self.t) assert_array_equal(self.f | self.f, self.f) assert_array_equal(self.t | self.f, self.t) assert_array_equal(self.f | self.t, self.t) np.logical_or(self.t, self.t, out=self.o) assert_array_equal(self.o, self.t) assert_array_equal(self.t & self.t, self.t) assert_array_equal(self.f & self.f, self.f) assert_array_equal(self.t & self.f, self.f) assert_array_equal(self.f & self.t, self.f) np.logical_and(self.t, self.t, out=self.o) assert_array_equal(self.o, self.t) assert_array_equal(self.t ^ self.t, self.f) assert_array_equal(self.f ^ self.f, self.f) assert_array_equal(self.t ^ self.f, self.t) assert_array_equal(self.f ^ self.t, self.t) np.logical_xor(self.t, self.t, out=self.o) assert_array_equal(self.o, self.f) assert_array_equal(self.nm & self.t, self.nm) assert_array_equal(self.im & self.f, False) assert_array_equal(self.nm & True, self.nm) assert_array_equal(self.im & False, self.f) assert_array_equal(self.nm | self.t, self.t) assert_array_equal(self.im | self.f, self.im) assert_array_equal(self.nm | True, self.t) assert_array_equal(self.im | False, self.im) assert_array_equal(self.nm ^ self.t, self.im) assert_array_equal(self.im ^ self.f, self.im) assert_array_equal(self.nm ^ True, self.im) assert_array_equal(self.im ^ False, self.im)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestBoolArray(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
setUp
def setUp(self): super().setUp() # offset for simd tests self.t = np.array([True] * 41, dtype=bool)[1::] self.f = np.array([False] * 41, dtype=bool)[1::] self.o = np.array([False] * 42, dtype=bool)[2::] self.nm = self.f.copy() self.im = self.t.copy() self.nm[3] = True self.nm[-2] = True self.im[3] = False self.im[-2] = False
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestBoolArray(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_float
def test_float(self): # offset for alignment test for i in range(4): assert_array_equal(self.f[i:] > 0, self.ef[i:]) assert_array_equal(self.f[i:] - 1 >= 0, self.ef[i:]) assert_array_equal(self.f[i:] == 0, ~self.ef[i:]) assert_array_equal(-self.f[i:] < 0, self.ef[i:]) assert_array_equal(-self.f[i:] + 1 <= 0, self.ef[i:]) r = self.f[i:] != 0 assert_array_equal(r, self.ef[i:]) r2 = self.f[i:] != np.zeros_like(self.f[i:]) r3 = 0 != self.f[i:] assert_array_equal(r, r2) assert_array_equal(r, r3) # check bool == 0x1 assert_array_equal(r.view(np.int8), r.astype(np.int8)) assert_array_equal(r2.view(np.int8), r2.astype(np.int8)) assert_array_equal(r3.view(np.int8), r3.astype(np.int8)) # isnan on amd64 takes the same code path assert_array_equal(np.isnan(self.nf[i:]), self.ef[i:]) assert_array_equal(np.isfinite(self.nf[i:]), ~self.ef[i:]) assert_array_equal(np.isfinite(self.inff[i:]), ~self.ef[i:]) assert_array_equal(np.isinf(self.inff[i:]), self.efnonan[i:]) assert_array_equal(np.signbit(self.signf[i:]), self.ef[i:])
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @xfailIfTorchDynamo class TestBoolCmp(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_double
def test_double(self): # offset for alignment test for i in range(2): assert_array_equal(self.d[i:] > 0, self.ed[i:]) assert_array_equal(self.d[i:] - 1 >= 0, self.ed[i:]) assert_array_equal(self.d[i:] == 0, ~self.ed[i:]) assert_array_equal(-self.d[i:] < 0, self.ed[i:]) assert_array_equal(-self.d[i:] + 1 <= 0, self.ed[i:]) r = self.d[i:] != 0 assert_array_equal(r, self.ed[i:]) r2 = self.d[i:] != np.zeros_like(self.d[i:]) r3 = 0 != self.d[i:] assert_array_equal(r, r2) assert_array_equal(r, r3) # check bool == 0x1 assert_array_equal(r.view(np.int8), r.astype(np.int8)) assert_array_equal(r2.view(np.int8), r2.astype(np.int8)) assert_array_equal(r3.view(np.int8), r3.astype(np.int8)) # isnan on amd64 takes the same code path assert_array_equal(np.isnan(self.nd[i:]), self.ed[i:]) assert_array_equal(np.isfinite(self.nd[i:]), ~self.ed[i:]) assert_array_equal(np.isfinite(self.infd[i:]), ~self.ed[i:]) assert_array_equal(np.isinf(self.infd[i:]), self.ednonan[i:]) assert_array_equal(np.signbit(self.signd[i:]), self.ed[i:])
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @xfailIfTorchDynamo class TestBoolCmp(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_default
def test_default(self): err = np.geterr() assert_equal( err, dict(divide="warn", invalid="warn", over="warn", under="ignore") )
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @xpassIfTorchDynamo # (reason="TODO") class TestSeterr(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_lengths
def test_lengths(self): expected = np.array(list(self.makegen())) a = np.fromiter(self.makegen(), int) a20 = np.fromiter(self.makegen(), int, 20) assert_(len(a) == len(expected)) assert_(len(a20) == 20) assert_raises(ValueError, np.fromiter, self.makegen(), int, len(expected) + 10)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @skip(reason="NP_VER: fails on CI") @xpassIfTorchDynamo # (reason="TODO") @instantiate_parametrized_tests class TestFromiter(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_values
def test_values(self): expected = np.array(list(self.makegen())) a = np.fromiter(self.makegen(), int) a20 = np.fromiter(self.makegen(), int, 20) assert_(np.all(a == expected, axis=0)) assert_(np.all(a20 == expected[:20], axis=0))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @skip(reason="NP_VER: fails on CI") @xpassIfTorchDynamo # (reason="TODO") @instantiate_parametrized_tests class TestFromiter(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_empty_result
def test_empty_result(self): class MyIter: def __length_hint__(self): return 10 def __iter__(self): return iter([]) # actual iterator is empty. res = np.fromiter(MyIter(), dtype="d") assert res.shape == (0,) assert res.dtype == "d"
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @skip(reason="NP_VER: fails on CI") @xpassIfTorchDynamo # (reason="TODO") @instantiate_parametrized_tests class TestFromiter(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
__length_hint__
def __length_hint__(self): return 10
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class MyIter:
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
__iter__
def __iter__(self): return iter([]) # actual iterator is empty.
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class MyIter:
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_too_few_items
def test_too_few_items(self): msg = "iterator too short: Expected 10 but iterator had only 3 items." with pytest.raises(ValueError, match=msg): np.fromiter([1, 2, 3], count=10, dtype=int)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @skip(reason="NP_VER: fails on CI") @xpassIfTorchDynamo # (reason="TODO") @instantiate_parametrized_tests class TestFromiter(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_failed_itemsetting
def test_failed_itemsetting(self): with pytest.raises(TypeError): np.fromiter([1, None, 3], dtype=int) # The following manages to hit somewhat trickier code paths: iterable = ((2, 3, 4) for i in range(5)) with pytest.raises(ValueError): np.fromiter(iterable, dtype=np.dtype((int, 2)))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @skip(reason="NP_VER: fails on CI") @xpassIfTorchDynamo # (reason="TODO") @instantiate_parametrized_tests class TestFromiter(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_count_nonzero_list
def test_count_nonzero_list(self): lst = [[0, 1, 2, 3], [1, 0, 0, 6]] assert np.count_nonzero(lst) == 5 assert_array_equal(np.count_nonzero(lst, axis=0), np.array([1, 1, 1, 2])) assert_array_equal(np.count_nonzero(lst, axis=1), np.array([3, 2]))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @instantiate_parametrized_tests class TestNonzeroAndCountNonzero(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
res_type
def res_type(a, b): return np.add(a, b).dtype self.check_promotion_cases(res_type) # Use-case: float/complex scalar * bool/int8 array # shouldn't narrow the float/complex type for a in [np.array([True, False]), np.array([-3, 12], dtype=np.int8)]: b = 1.234 * a assert_equal(b.dtype, np.dtype("f8"), f"array type {a.dtype}") b = np.float64(1.234) * a assert_equal(b.dtype, np.dtype("f8"), f"array type {a.dtype}") b = np.float32(1.234) * a assert_equal(b.dtype, np.dtype("f4"), f"array type {a.dtype}") b = np.float16(1.234) * a assert_equal(b.dtype, np.dtype("f2"), f"array type {a.dtype}") b = 1.234j * a assert_equal(b.dtype, np.dtype("c16"), f"array type {a.dtype}") b = np.complex128(1.234j) * a assert_equal(b.dtype, np.dtype("c16"), f"array type {a.dtype}") b = np.complex64(1.234j) * a assert_equal(b.dtype, np.dtype("c8"), f"array type {a.dtype}") # The following use-case is problematic, and to resolve its # tricky side-effects requires more changes. # # Use-case: (1-t)*a, where 't' is a boolean array and 'a' is # a float32, shouldn't promote to float64 # # a = np.array([1.0, 1.5], dtype=np.float32) # t = np.array([True, False]) # b = t*a # assert_equal(b, [1.0, 0.0]) # assert_equal(b.dtype, np.dtype('f4')) # b = (1-t)*a # assert_equal(b, [0.0, 1.5]) # assert_equal(b.dtype, np.dtype('f4')) # # Probably ~t (bitwise negation) is more proper to use here, # but this is arguably less intuitive to understand at a glance, and # would fail if 't' is actually an integer array instead of boolean: # # b = (~t)*a # assert_equal(b, [0.0, 1.5]) # assert_equal(b.dtype, np.dtype('f4'))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
res_type
def res_type(a, b): return np.add(a, b).dtype self.check_promotion_cases(res_type) # Use-case: float/complex scalar * bool/int8 array # shouldn't narrow the float/complex type for a in [np.array([True, False]), np.array([-3, 12], dtype=np.int8)]: b = 1.234 * a assert_equal(b.dtype, np.dtype("f8"), f"array type {a.dtype}") b = np.float64(1.234) * a assert_equal(b.dtype, np.dtype("f8"), f"array type {a.dtype}") b = np.float32(1.234) * a assert_equal(b.dtype, np.dtype("f4"), f"array type {a.dtype}") b = np.float16(1.234) * a assert_equal(b.dtype, np.dtype("f2"), f"array type {a.dtype}") b = 1.234j * a assert_equal(b.dtype, np.dtype("c16"), f"array type {a.dtype}") b = np.complex128(1.234j) * a assert_equal(b.dtype, np.dtype("c16"), f"array type {a.dtype}") b = np.complex64(1.234j) * a assert_equal(b.dtype, np.dtype("c8"), f"array type {a.dtype}") # The following use-case is problematic, and to resolve its # tricky side-effects requires more changes. # # Use-case: (1-t)*a, where 't' is a boolean array and 'a' is # a float32, shouldn't promote to float64 # # a = np.array([1.0, 1.5], dtype=np.float32) # t = np.array([True, False]) # b = t*a # assert_equal(b, [1.0, 0.0]) # assert_equal(b.dtype, np.dtype('f4')) # b = (1-t)*a # assert_equal(b, [0.0, 1.5]) # assert_equal(b.dtype, np.dtype('f4')) # # Probably ~t (bitwise negation) is more proper to use here, # but this is arguably less intuitive to understand at a glance, and # would fail if 't' is actually an integer array instead of boolean: # # b = (~t)*a # assert_equal(b, [0.0, 1.5]) # assert_equal(b.dtype, np.dtype('f4'))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_promote_types_endian
def test_promote_types_endian(self): # promote_types should always return native-endian types assert_equal(np.promote_types("<i8", "<i8"), np.dtype("i8")) assert_equal(np.promote_types(">i8", ">i8"), np.dtype("i8"))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestTypes(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_can_cast_values
def test_can_cast_values(self): # gh-5917 for dt in [np.int8, np.int16, np.int32, np.int64] + [ np.uint8, np.uint16, np.uint32, np.uint64, ]: ii = np.iinfo(dt) assert_(np.can_cast(ii.min, dt)) assert_(np.can_cast(ii.max, dt)) assert_(not np.can_cast(ii.min - 1, dt)) assert_(not np.can_cast(ii.max + 1, dt)) for dt in [np.float16, np.float32, np.float64, np.longdouble]: fi = np.finfo(dt) assert_(np.can_cast(fi.min, dt)) assert_(np.can_cast(fi.max, dt)) # Custom exception class to test exception propagation in fromiter
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestTypes(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
makegen
def makegen(self): return (x**2 for x in range(24))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @skip(reason="NP_VER: fails on CI") @xpassIfTorchDynamo # (reason="TODO") @instantiate_parametrized_tests class TestFromiter(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_types
def test_types(self): ai32 = np.fromiter(self.makegen(), np.int32) ai64 = np.fromiter(self.makegen(), np.int64) af = np.fromiter(self.makegen(), float) assert_(ai32.dtype == np.dtype(np.int32)) assert_(ai64.dtype == np.dtype(np.int64)) assert_(af.dtype == np.dtype(float))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @skip(reason="NP_VER: fails on CI") @xpassIfTorchDynamo # (reason="TODO") @instantiate_parametrized_tests class TestFromiter(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_nonzero_trivial
def test_nonzero_trivial(self): assert_equal(np.count_nonzero(np.array([])), 0) assert_equal(np.count_nonzero(np.array([], dtype="?")), 0) assert_equal(np.nonzero(np.array([])), ([],)) assert_equal(np.count_nonzero(np.array([0])), 0) assert_equal(np.count_nonzero(np.array([0], dtype="?")), 0) assert_equal(np.nonzero(np.array([0])), ([],)) assert_equal(np.count_nonzero(np.array([1])), 1) assert_equal(np.count_nonzero(np.array([1], dtype="?")), 1) assert_equal(np.nonzero(np.array([1])), ([0],))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @instantiate_parametrized_tests class TestNonzeroAndCountNonzero(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_nonzero_trivial_differs
def test_nonzero_trivial_differs(self): # numpy returns a python int, we return a 0D array assert isinstance(np.count_nonzero([]), np.ndarray)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @instantiate_parametrized_tests class TestNonzeroAndCountNonzero(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_nonzero_zerod
def test_nonzero_zerod(self): assert_equal(np.count_nonzero(np.array(0)), 0) assert_equal(np.count_nonzero(np.array(0, dtype="?")), 0) assert_equal(np.count_nonzero(np.array(1)), 1) assert_equal(np.count_nonzero(np.array(1, dtype="?")), 1)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @instantiate_parametrized_tests class TestNonzeroAndCountNonzero(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_nonzero_zerod_differs
def test_nonzero_zerod_differs(self): # numpy returns a python int, we return a 0D array assert isinstance(np.count_nonzero(np.array(1)), np.ndarray)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @instantiate_parametrized_tests class TestNonzeroAndCountNonzero(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_nonzero_onedim
def test_nonzero_onedim(self): x = np.array([1, 0, 2, -1, 0, 0, 8]) assert_equal(np.count_nonzero(x), 4) assert_equal(np.count_nonzero(x), 4) assert_equal(np.nonzero(x), ([0, 2, 3, 6],))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @instantiate_parametrized_tests class TestNonzeroAndCountNonzero(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_nonzero_onedim_differs
def test_nonzero_onedim_differs(self): # numpy returns a python int, we return a 0D array x = np.array([1, 0, 2, -1, 0, 0, 8]) assert isinstance(np.count_nonzero(x), np.ndarray)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @instantiate_parametrized_tests class TestNonzeroAndCountNonzero(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_nonzero_twodim
def test_nonzero_twodim(self): x = np.array([[0, 1, 0], [2, 0, 3]]) assert_equal(np.count_nonzero(x.astype("i1")), 3) assert_equal(np.count_nonzero(x.astype("i2")), 3) assert_equal(np.count_nonzero(x.astype("i4")), 3) assert_equal(np.count_nonzero(x.astype("i8")), 3) assert_equal(np.nonzero(x), ([0, 1, 1], [1, 0, 2])) x = np.eye(3) assert_equal(np.count_nonzero(x.astype("i1")), 3) assert_equal(np.count_nonzero(x.astype("i2")), 3) assert_equal(np.count_nonzero(x.astype("i4")), 3) assert_equal(np.count_nonzero(x.astype("i8")), 3) assert_equal(np.nonzero(x), ([0, 1, 2], [0, 1, 2]))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @instantiate_parametrized_tests class TestNonzeroAndCountNonzero(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_sparse
def test_sparse(self): # test special sparse condition boolean code path for i in range(20): c = np.zeros(200, dtype=bool) c[i::20] = True assert_equal(np.nonzero(c)[0], np.arange(i, 200 + i, 20)) c = np.zeros(400, dtype=bool) c[10 + i : 20 + i] = True c[20 + i * 2] = True assert_equal( np.nonzero(c)[0], np.concatenate((np.arange(10 + i, 20 + i), [20 + i * 2])), )
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @instantiate_parametrized_tests class TestNonzeroAndCountNonzero(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_count_nonzero_axis_all_dtypes
def test_count_nonzero_axis_all_dtypes(self, typecode): # More thorough test that the axis argument is respected # for all dtypes and responds correctly when presented with # either integer or tuple arguments for axis m = np.zeros((3, 3), dtype=typecode) n = np.ones(1, dtype=typecode) m[0, 0] = n[0] m[1, 0] = n[0] expected = np.array([2, 0, 0], dtype=np.intp) result = np.count_nonzero(m, axis=0) assert_array_equal(result, expected) assert expected.dtype == result.dtype expected = np.array([1, 1, 0], dtype=np.intp) result = np.count_nonzero(m, axis=1) assert_array_equal(result, expected) assert expected.dtype == result.dtype expected = np.array(2) assert_array_equal(np.count_nonzero(m, axis=(0, 1)), expected) assert_array_equal(np.count_nonzero(m, axis=None), expected) assert_array_equal(np.count_nonzero(m), expected)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @instantiate_parametrized_tests class TestNonzeroAndCountNonzero(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_errobj
def test_errobj(self): olderrobj = np.geterrobj() self.called = 0 try: with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") np.seterrobj([20000, 1, None]) np.array([1.0]) / np.array([0.0]) assert_equal(len(w), 1) def log_err(*args): self.called += 1 extobj_err = args assert_(len(extobj_err) == 2) assert_("divide" in extobj_err[0]) np.seterrobj([20000, 3, log_err]) np.array([1.0]) / np.array([0.0]) assert_equal(self.called, 1) np.seterrobj(olderrobj) np.divide(1.0, 0.0, extobj=[20000, 3, log_err]) assert_equal(self.called, 2) finally: np.seterrobj(olderrobj) del self.called
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @xpassIfTorchDynamo # (reason="TODO") class TestSeterr(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
log_err
def log_err(*args): self.called += 1 extobj_err = args assert_(len(extobj_err) == 2) assert_("divide" in extobj_err[0]) np.seterrobj([20000, 3, log_err]) np.array([1.0]) / np.array([0.0]) assert_equal(self.called, 1) np.seterrobj(olderrobj) np.divide(1.0, 0.0, extobj=[20000, 3, log_err]) assert_equal(self.called, 2)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
assert_raises_fpe
def assert_raises_fpe(self, fpeerr, flop, x, y): ftype = type(x) try: flop(x, y) assert_(False, f"Type {ftype} did not raise fpe error '{fpeerr}'.") except FloatingPointError as exc: assert_( str(exc).find(fpeerr) >= 0, f"Type {ftype} raised wrong fpe error '{exc}'.", )
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @xfail # (reason="TODO") @instantiate_parametrized_tests class TestFloatExceptions(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_warnings
def test_warnings(self): # test warning code path with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") np.divide(1, 0.0) assert_equal(len(w), 1) assert_("divide by zero" in str(w[0].message)) np.array(1e300) * np.array(1e300) assert_equal(len(w), 2) assert_("overflow" in str(w[-1].message)) np.array(np.inf) - np.array(np.inf) assert_equal(len(w), 3) assert_("invalid value" in str(w[-1].message)) np.array(1e-300) * np.array(1e-300) assert_equal(len(w), 4) assert_("underflow" in str(w[-1].message))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @xfail # (reason="TODO") @instantiate_parametrized_tests class TestFloatExceptions(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
check_promotion_cases
def check_promotion_cases(self, promote_func): # tests that the scalars get coerced correctly. b = np.bool_(0) i8, i16, i32, i64 = np.int8(0), np.int16(0), np.int32(0), np.int64(0) u8 = np.uint8(0) f32, f64 = np.float32(0), np.float64(0) c64, c128 = np.complex64(0), np.complex128(0) # coercion within the same kind assert_equal(promote_func(i8, i16), np.dtype(np.int16)) assert_equal(promote_func(i32, i8), np.dtype(np.int32)) assert_equal(promote_func(i16, i64), np.dtype(np.int64)) assert_equal(promote_func(f32, f64), np.dtype(np.float64)) assert_equal(promote_func(c128, c64), np.dtype(np.complex128)) # coercion between kinds assert_equal(promote_func(b, i32), np.dtype(np.int32)) assert_equal(promote_func(b, u8), np.dtype(np.uint8)) assert_equal(promote_func(i8, u8), np.dtype(np.int16)) assert_equal(promote_func(u8, i32), np.dtype(np.int32)) assert_equal(promote_func(f32, i16), np.dtype(np.float32)) assert_equal(promote_func(f32, c64), np.dtype(np.complex64)) assert_equal(promote_func(c128, f32), np.dtype(np.complex128)) # coercion between scalars and 1-D arrays assert_equal(promote_func(np.array([b]), i8), np.dtype(np.int8)) assert_equal(promote_func(np.array([b]), u8), np.dtype(np.uint8)) assert_equal(promote_func(np.array([b]), i32), np.dtype(np.int32)) assert_equal(promote_func(c64, np.array([f64])), np.dtype(np.complex128)) assert_equal( promote_func(np.complex64(3j), np.array([f64])), np.dtype(np.complex128) ) # coercion between scalars and 1-D arrays, where # the scalar has greater kind than the array assert_equal(promote_func(np.array([b]), f64), np.dtype(np.float64)) assert_equal(promote_func(np.array([b]), i64), np.dtype(np.int64)) assert_equal(promote_func(np.array([i8]), f64), np.dtype(np.float64))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestTypes(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
check_promotion_cases_2
def check_promotion_cases_2(self, promote_func): # these are failing because of the "scalars do not upcast arrays" rule # Two first tests (i32 + f32 -> f64, and i64+f32 -> f64) xfail # until ufuncs implement the proper type promotion (ufunc loops?) b = np.bool_(0) i8, i16, i32, i64 = np.int8(0), np.int16(0), np.int32(0), np.int64(0) u8 = np.uint8(0) f32, f64 = np.float32(0), np.float64(0) c64, c128 = np.complex64(0), np.complex128(0) assert_equal(promote_func(i32, f32), np.dtype(np.float64)) assert_equal(promote_func(i64, f32), np.dtype(np.float64)) assert_equal(promote_func(np.array([i8]), i64), np.dtype(np.int8)) assert_equal(promote_func(f64, np.array([f32])), np.dtype(np.float32)) # float and complex are treated as the same "kind" for # the purposes of array-scalar promotion, so that you can do # (0j + float32array) to get a complex64 array instead of # a complex128 array. assert_equal(promote_func(np.array([f32]), c128), np.dtype(np.complex64))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestTypes(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_base3
def test_base3(self): assert_equal(np.base_repr(3**5, 3), "100000")
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @xpassIfTorchDynamo # (reason="TODO") class TestBaseRepr(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_positive
def test_positive(self): assert_equal(np.binary_repr(10), "1010") assert_equal(np.binary_repr(12522), "11000011101010") assert_equal(np.binary_repr(10736848), "101000111101010011010000")
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @xpassIfTorchDynamo # (reason="TODO") class TestBinaryRepr(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_negative
def test_negative(self): assert_equal(np.binary_repr(-1), "-1") assert_equal(np.binary_repr(-10), "-1010") assert_equal(np.binary_repr(-12522), "-11000011101010") assert_equal(np.binary_repr(-10736848), "-101000111101010011010000")
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @xpassIfTorchDynamo # (reason="TODO") class TestBinaryRepr(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_base_range
def test_base_range(self): with assert_raises(ValueError): np.base_repr(1, 1) with assert_raises(ValueError): np.base_repr(1, 37)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @xpassIfTorchDynamo # (reason="TODO") class TestBaseRepr(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_array_equal
def test_array_equal(self): res = np.array_equal(np.array([1, 2]), np.array([1, 2])) assert_(res) assert_(type(res) is bool) res = np.array_equal(np.array([1, 2]), np.array([1, 2, 3])) assert_(not res) assert_(type(res) is bool) res = np.array_equal(np.array([1, 2]), np.array([3, 4])) assert_(not res) assert_(type(res) is bool) res = np.array_equal(np.array([1, 2]), np.array([1, 3])) assert_(not res) assert_(type(res) is bool)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestArrayComparisons(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_array_equal_equal_nan
def test_array_equal_equal_nan(self): # Test array_equal with equal_nan kwarg a1 = np.array([1, 2, np.nan]) a2 = np.array([1, np.nan, 2]) a3 = np.array([1, 2, np.inf]) # equal_nan=False by default assert_(not np.array_equal(a1, a1)) assert_(np.array_equal(a1, a1, equal_nan=True)) assert_(not np.array_equal(a1, a2, equal_nan=True)) # nan's not conflated with inf's assert_(not np.array_equal(a1, a3, equal_nan=True)) # 0-D arrays a = np.array(np.nan) assert_(not np.array_equal(a, a)) assert_(np.array_equal(a, a, equal_nan=True)) # Non-float dtype - equal_nan should have no effect a = np.array([1, 2, 3], dtype=int) assert_(np.array_equal(a, a)) assert_(np.array_equal(a, a, equal_nan=True)) # Multi-dimensional array a = np.array([[0, 1], [np.nan, 1]]) assert_(not np.array_equal(a, a)) assert_(np.array_equal(a, a, equal_nan=True)) # Complex values a, b = [np.array([1 + 1j])] * 2 a.real, b.imag = np.nan, np.nan assert_(not np.array_equal(a, b, equal_nan=False)) assert_(np.array_equal(a, b, equal_nan=True))
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestArrayComparisons(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_none_compares_elementwise
def test_none_compares_elementwise(self): a = np.ones(3) assert_equal(a.__eq__(None), [False, False, False]) assert_equal(a.__ne__(None), [True, True, True])
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestArrayComparisons(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
test_array_equiv
def test_array_equiv(self): res = np.array_equiv(np.array([1, 2]), np.array([1, 2])) assert_(res) assert_(type(res) is bool) res = np.array_equiv(np.array([1, 2]), np.array([1, 2, 3])) assert_(not res) assert_(type(res) is bool) res = np.array_equiv(np.array([1, 2]), np.array([3, 4])) assert_(not res) assert_(type(res) is bool) res = np.array_equiv(np.array([1, 2]), np.array([1, 3])) assert_(not res) assert_(type(res) is bool) res = np.array_equiv(np.array([1, 1]), np.array([1])) assert_(res) assert_(type(res) is bool) res = np.array_equiv(np.array([1, 1]), np.array([[1], [1]])) assert_(res) assert_(type(res) is bool) res = np.array_equiv(np.array([1, 2]), np.array([2])) assert_(not res) assert_(type(res) is bool) res = np.array_equiv(np.array([1, 2]), np.array([[1], [2]])) assert_(not res) assert_(type(res) is bool) res = np.array_equiv( np.array([1, 2]), np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) ) assert_(not res) assert_(type(res) is bool)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestArrayComparisons(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
setUp
def setUp(self): super().setUp() # offset for simd tests self.t = np.array([True] * 41, dtype=bool)[1::] self.f = np.array([False] * 41, dtype=bool)[1::] self.o = np.array([False] * 42, dtype=bool)[2::] self.nm = self.f.copy() self.im = self.t.copy() self.nm[3] = True self.nm[-2] = True self.im[3] = False self.im[-2] = False
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number class TestBoolArray(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
fastclip
def fastclip(self, a, m, M, out=None, casting=None): if out is None: if casting is None: return a.clip(m, M) else: return a.clip(m, M, casting=casting) else: if casting is None: return a.clip(m, M, out) else: return a.clip(m, M, out, casting=casting)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @instantiate_parametrized_tests class TestClip(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
clip
def clip(self, a, m, M, out=None): # use slow-clip selector = np.less(a, m) + 2 * np.greater(a, M) return selector.choose((a, m, M), out=out) # Handy functions
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @instantiate_parametrized_tests class TestClip(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
_generate_data
def _generate_data(self, n, m): return randn(n, m)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @instantiate_parametrized_tests class TestClip(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_numeric.py
_generate_data_complex
def _generate_data_complex(self, n, m): return randn(n, m) + 1.0j * rand(n, m)
import functools import itertools import math import platform import sys import warnings import numpy import pytest IS_WASM = False HAS_REFCOUNT = True import operator from unittest import expectedFailure as xfail, skipIf as skipif, SkipTest from hypothesis import given, strategies as st from hypothesis.extra import numpy as hynp from pytest import raises as assert_raises from torch.testing._internal.common_utils import ( instantiate_parametrized_tests, parametrize, run_tests, subtest, TEST_WITH_TORCHDYNAMO, TestCase, xfailIfTorchDynamo, xpassIfTorchDynamo, ) import numpy as np from numpy.random import rand, randint, randn from numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) import torch._numpy as np from torch._numpy.random import rand, randint, randn from torch._numpy.testing import ( assert_, assert_allclose, assert_almost_equal, assert_array_almost_equal, assert_array_equal, assert_equal, assert_warns, # assert_array_max_ulp, HAS_REFCOUNT, IS_WASM ) skip = functools.partial(skipif, True) from fractions import Fraction from numbers import Number @instantiate_parametrized_tests class TestClip(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added