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_huge_vectordot
def test_huge_vectordot(self, dtype): # Large vector multiplications are chunked with 32bit BLAS # Test that the chunking does the right thing, see also gh-22262 data = np.ones(2**30 + 100, dtype=dtype) res = np.dot(data, data) assert res == 2**30 + 100
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 []), } @instantiate_parametrized_tests class TestDot(TestCase): from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_dotmatvec
def test_dotmatvec(self): A, b1 = self.A, self.b1 res = np.dot(A, b1) tgt = np.array([[0.32114320], [0.04889721], [0.15696029], [0.33612621]]) assert_almost_equal(res, tgt, decimal=self.N)
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 []), } @instantiate_parametrized_tests class TestDot(TestCase): from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_dotmatvec2
def test_dotmatvec2(self): A, b2 = self.A, self.b2 res = np.dot(A, b2) tgt = np.array([0.29677940, 0.04518649, 0.14468333, 0.31039293]) assert_almost_equal(res, tgt, decimal=self.N)
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 []), } @instantiate_parametrized_tests class TestDot(TestCase): from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_dotvecmat
def test_dotvecmat(self): A, b4 = self.A, self.b4 res = np.dot(b4, A) tgt = np.array([1.23495091, 1.12222648]) assert_almost_equal(res, tgt, decimal=self.N)
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 []), } @instantiate_parametrized_tests class TestDot(TestCase): from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_dotvecmat2
def test_dotvecmat2(self): b3, A = self.b3, self.A res = np.dot(b3, A.transpose()) tgt = np.array([[0.58793804, 0.08957460, 0.30605758, 0.62716383]]) assert_almost_equal(res, tgt, decimal=self.N)
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 []), } @instantiate_parametrized_tests class TestDot(TestCase): from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_dotvecmat3
def test_dotvecmat3(self): A, b4 = self.A, self.b4 res = np.dot(A.transpose(), b4) tgt = np.array([1.23495091, 1.12222648]) assert_almost_equal(res, tgt, decimal=self.N)
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 []), } @instantiate_parametrized_tests class TestDot(TestCase): from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_dotvecvecouter
def test_dotvecvecouter(self): b1, b3 = self.b1, self.b3 res = np.dot(b1, b3) tgt = np.array([[0.20128610, 0.08400440], [0.07190947, 0.03001058]]) assert_almost_equal(res, tgt, decimal=self.N)
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 []), } @instantiate_parametrized_tests class TestDot(TestCase): from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_dotvecvecinner
def test_dotvecvecinner(self): b1, b3 = self.b1, self.b3 res = np.dot(b3, b1) tgt = np.array([[0.23129668]]) assert_almost_equal(res, tgt, decimal=self.N)
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 []), } @instantiate_parametrized_tests class TestDot(TestCase): from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_dotcolumnvect1
def test_dotcolumnvect1(self): b1 = np.ones((3, 1)) b2 = [5.3] res = np.dot(b1, b2) tgt = np.array([5.3, 5.3, 5.3]) assert_almost_equal(res, tgt, decimal=self.N)
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 []), } @instantiate_parametrized_tests class TestDot(TestCase): from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_dotcolumnvect2
def test_dotcolumnvect2(self): b1 = np.ones((3, 1)).transpose() b2 = [6.2] res = np.dot(b2, b1) tgt = np.array([6.2, 6.2, 6.2]) assert_almost_equal(res, tgt, decimal=self.N)
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 []), } @instantiate_parametrized_tests class TestDot(TestCase): from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_dotvecscalar
def test_dotvecscalar(self): np.random.seed(100) # Numpy guarantees the random stream, and we don't. So inline the # values from numpy 1.24.1 # b1 = np.random.rand(1, 1) b1 = np.array([[0.54340494]]) # b2 = np.random.rand(1, 4) b2 = np.array([[0.27836939, 0.42451759, 0.84477613, 0.00471886]]) res = np.dot(b1, b2) tgt = np.array([[0.15126730, 0.23068496, 0.45905553, 0.00256425]]) assert_almost_equal(res, tgt, decimal=self.N)
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 []), } @instantiate_parametrized_tests class TestDot(TestCase): from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_exceptions
def test_exceptions(self): dims = [ ((1,), (2,)), # mismatched vector vector ( ( 2, 1, ), (2,), ), # mismatched matrix vector ((2,), (1, 2)), # mismatched vector matrix ((1, 2), (3, 1)), # mismatched matrix matrix ((1,), ()), # vector scalar ((), (1)), # scalar vector ((1, 1), ()), # matrix scalar ((), (1, 1)), # scalar matrix ((2, 2, 1), (3, 1, 2)), # cannot broadcast ] for dt, (dm1, dm2) in itertools.product(self.types, dims): a = np.ones(dm1, dtype=dt) b = np.ones(dm2, dtype=dt) assert_raises((RuntimeError, ValueError), self.matmul, a, b)
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 class MatmulCommon: import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_shapes
def test_shapes(self): dims = [ ((1, 1), (2, 1, 1)), # broadcast first argument ((2, 1, 1), (1, 1)), # broadcast second argument ((2, 1, 1), (2, 1, 1)), # matrix stack sizes match ] for dt, (dm1, dm2) in itertools.product(self.types, dims): a = np.ones(dm1, dtype=dt) b = np.ones(dm2, dtype=dt) res = self.matmul(a, b) assert_(res.shape == (2, 1, 1)) # vector vector returns scalars. for dt in self.types: a = np.ones((2,), dtype=dt) b = np.ones((2,), dtype=dt) c = self.matmul(a, b) assert_(np.array(c).shape == ())
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 class MatmulCommon: import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_result_types_2
def test_result_types_2(self): # in numpy, vector vector returns scalars # we return a 0D array instead for dt in self.types: v = np.ones((1,)).astype(dt) if dt != "O": res = self.matmul(v, v) assert_(type(res) is np.dtype(dt).type)
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 class MatmulCommon: import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_scalar_output
def test_scalar_output(self): vec1 = np.array([2]) vec2 = np.array([3, 4]).reshape(1, -1) tgt = np.array([6, 8]) for dt in self.types[1:]: v1 = vec1.astype(dt) v2 = vec2.astype(dt) res = self.matmul(v1, v2) assert_equal(res, tgt) res = self.matmul(v2.T, v1) assert_equal(res, tgt) # boolean type vec = np.array([True, True], dtype="?").reshape(1, -1) res = self.matmul(vec[:, 0], vec) assert_equal(res, 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 class MatmulCommon: import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_vector_vector_values
def test_vector_vector_values(self): vec1 = np.array([1, 2]) vec2 = np.array([3, 4]).reshape(-1, 1) tgt1 = np.array([11]) tgt2 = np.array([[3, 6], [4, 8]]) for dt in self.types[1:]: v1 = vec1.astype(dt) v2 = vec2.astype(dt) res = self.matmul(v1, v2) assert_equal(res, tgt1) # no broadcast, we must make v1 into a 2d ndarray res = self.matmul(v2, v1.reshape(1, -1)) assert_equal(res, tgt2) # boolean type vec = np.array([True, True], dtype="?") res = self.matmul(vec, vec) assert_equal(res, 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 class MatmulCommon: import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_vector_matrix_values
def test_vector_matrix_values(self): vec = np.array([1, 2]) mat1 = np.array([[1, 2], [3, 4]]) mat2 = np.stack([mat1] * 2, axis=0) tgt1 = np.array([7, 10]) tgt2 = np.stack([tgt1] * 2, axis=0) for dt in self.types[1:]: v = vec.astype(dt) m1 = mat1.astype(dt) m2 = mat2.astype(dt) res = self.matmul(v, m1) assert_equal(res, tgt1) res = self.matmul(v, m2) assert_equal(res, tgt2) # boolean type vec = np.array([True, False]) mat1 = np.array([[True, False], [False, True]]) mat2 = np.stack([mat1] * 2, axis=0) tgt1 = np.array([True, False]) tgt2 = np.stack([tgt1] * 2, axis=0) res = self.matmul(vec, mat1) assert_equal(res, tgt1) res = self.matmul(vec, mat2) assert_equal(res, tgt2)
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 class MatmulCommon: import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_matrix_vector_values
def test_matrix_vector_values(self): vec = np.array([1, 2]) mat1 = np.array([[1, 2], [3, 4]]) mat2 = np.stack([mat1] * 2, axis=0) tgt1 = np.array([5, 11]) tgt2 = np.stack([tgt1] * 2, axis=0) for dt in self.types[1:]: v = vec.astype(dt) m1 = mat1.astype(dt) m2 = mat2.astype(dt) res = self.matmul(m1, v) assert_equal(res, tgt1) res = self.matmul(m2, v) assert_equal(res, tgt2) # boolean type vec = np.array([True, False]) mat1 = np.array([[True, False], [False, True]]) mat2 = np.stack([mat1] * 2, axis=0) tgt1 = np.array([True, False]) tgt2 = np.stack([tgt1] * 2, axis=0) res = self.matmul(vec, mat1) assert_equal(res, tgt1) res = self.matmul(vec, mat2) assert_equal(res, tgt2)
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 class MatmulCommon: import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_matrix_matrix_values
def test_matrix_matrix_values(self): mat1 = np.array([[1, 2], [3, 4]]) mat2 = np.array([[1, 0], [1, 1]]) mat12 = np.stack([mat1, mat2], axis=0) mat21 = np.stack([mat2, mat1], axis=0) tgt11 = np.array([[7, 10], [15, 22]]) tgt12 = np.array([[3, 2], [7, 4]]) tgt21 = np.array([[1, 2], [4, 6]]) tgt12_21 = np.stack([tgt12, tgt21], axis=0) tgt11_12 = np.stack((tgt11, tgt12), axis=0) tgt11_21 = np.stack((tgt11, tgt21), axis=0) for dt in self.types[1:]: m1 = mat1.astype(dt) m2 = mat2.astype(dt) m12 = mat12.astype(dt) m21 = mat21.astype(dt) # matrix @ matrix res = self.matmul(m1, m2) assert_equal(res, tgt12) res = self.matmul(m2, m1) assert_equal(res, tgt21) # stacked @ matrix res = self.matmul(m12, m1) assert_equal(res, tgt11_21) # matrix @ stacked res = self.matmul(m1, m12) assert_equal(res, tgt11_12) # stacked @ stacked res = self.matmul(m12, m21) assert_equal(res, tgt12_21) # boolean type m1 = np.array([[1, 1], [0, 0]], dtype=np.bool_) m2 = np.array([[1, 0], [1, 1]], dtype=np.bool_) m12 = np.stack([m1, m2], axis=0) m21 = np.stack([m2, m1], axis=0) tgt11 = m1 tgt12 = m1 tgt21 = np.array([[1, 1], [1, 1]], dtype=np.bool_) tgt12_21 = np.stack([tgt12, tgt21], axis=0) tgt11_12 = np.stack((tgt11, tgt12), axis=0) tgt11_21 = np.stack((tgt11, tgt21), axis=0) # matrix @ matrix res = self.matmul(m1, m2) assert_equal(res, tgt12) res = self.matmul(m2, m1) assert_equal(res, tgt21) # stacked @ matrix res = self.matmul(m12, m1) assert_equal(res, tgt11_21) # matrix @ stacked res = self.matmul(m1, m12) assert_equal(res, tgt11_12) # stacked @ stacked res = self.matmul(m12, m21) assert_equal(res, tgt12_21)
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 class MatmulCommon: import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_out_arg
def test_out_arg(self): a = np.ones((5, 2), dtype=float) b = np.array([[1, 3], [5, 7]], dtype=float) tgt = np.dot(a, b) # test as positional argument msg = "out positional argument" out = np.zeros((5, 2), dtype=float) self.matmul(a, b, out) assert_array_equal(out, tgt, err_msg=msg) # test as keyword argument msg = "out keyword argument" out = np.zeros((5, 2), dtype=float) self.matmul(a, b, out=out) assert_array_equal(out, tgt, err_msg=msg) # test out with not allowed type cast (safe casting) msg = "Cannot cast" out = np.zeros((5, 2), dtype=np.int32) assert_raises_regex(TypeError, msg, self.matmul, a, b, out=out) # test out with type upcast to complex out = np.zeros((5, 2), dtype=np.complex128) c = self.matmul(a, b, out=out) assert_(c is out) # with suppress_warnings() as sup: # sup.filter(np.ComplexWarning, '') c = c.astype(tgt.dtype) assert_array_equal(c, tgt)
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 @instantiate_parametrized_tests class TestMatmul(MatmulCommon, TestCase): import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_empty_out
def test_empty_out(self): # Check that the output cannot be broadcast, so that it cannot be # size zero when the outer dimensions (iterator size) has size zero. arr = np.ones((0, 1, 1)) out = np.ones((1, 1, 1)) assert self.matmul(arr, arr).shape == (0, 1, 1) with pytest.raises((RuntimeError, ValueError)): self.matmul(arr, arr, out=out)
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 @instantiate_parametrized_tests class TestMatmul(MatmulCommon, TestCase): import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
__add__
def __add__(self, other): return self
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 class add_not_multiply: import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_matmul_exception_add
def test_matmul_exception_add(self): # test that matmul fails if `__add__` is missing class multiply_not_add: def __mul__(self, other): return self a = np.full((3, 3), multiply_not_add()) with assert_raises(TypeError): b = np.matmul(a, a)
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 @instantiate_parametrized_tests class TestMatmul(MatmulCommon, TestCase): import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
__mul__
def __mul__(self, other): return self
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 class multiply_not_add: import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_matmul_bool
def test_matmul_bool(self): # gh-14439 a = np.array([[1, 0], [1, 1]], dtype=bool) assert np.max(a.view(np.uint8)) == 1 b = np.matmul(a, a) # matmul with boolean output should always be 0, 1 assert np.max(b.view(np.uint8)) == 1 # rg = np.random.default_rng(np.random.PCG64(43)) # d = rg.integers(2, size=4*5, dtype=np.int8) # d = d.reshape(4, 5) > 0 np.random.seed(1234) d = np.random.randint(2, size=(4, 5)) > 0 out1 = np.matmul(d, d.reshape(5, 4)) out2 = np.dot(d, d.reshape(5, 4)) assert_equal(out1, out2) c = np.matmul(np.zeros((2, 0), dtype=bool), np.zeros(0, dtype=bool)) assert not np.any(c)
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 @instantiate_parametrized_tests class TestMatmul(MatmulCommon, TestCase): import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_array_priority_override
def test_array_priority_override(self): class A: __array_priority__ = 1000 def __matmul__(self, other): return "A" def __rmatmul__(self, other): return "A" a = A() b = np.ones(2) assert_equal(self.matmul(a, b), "A") assert_equal(self.matmul(b, a), "A")
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 class TestMatmulOperator(MatmulCommon, TestCase): import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
__matmul__
def __matmul__(self, other): return "A"
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 class A: from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
__rmatmul__
def __rmatmul__(self, other): return "A"
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 class A: from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_matmul_axes
def test_matmul_axes(self): a = np.arange(3 * 4 * 5).reshape(3, 4, 5) c = np.matmul(a, a, axes=[(-2, -1), (-1, -2), (1, 2)]) assert c.shape == (3, 4, 4) d = np.matmul(a, a, axes=[(-2, -1), (-1, -2), (0, 1)]) assert d.shape == (4, 4, 3) e = np.swapaxes(d, 0, 2) assert_array_equal(e, c) f = np.matmul(a, np.arange(3), axes=[(1, 0), (0), (0)]) assert f.shape == (4, 5)
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 class TestMatmulOperator(MatmulCommon, TestCase): import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_inner_scalar_and_vector
def test_inner_scalar_and_vector(self): for dt in np.typecodes["AllInteger"] + np.typecodes["AllFloat"] + "?": sca = np.array(3, dtype=dt)[()] vec = np.array([1, 2], dtype=dt) desired = np.array([3, 6], dtype=dt) assert_equal(np.inner(vec, sca), desired) assert_equal(np.inner(sca, vec), desired)
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 class TestInner(TestCase): from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_vecself
def test_vecself(self): # Ticket 844. # Inner product of a vector with itself segfaults or give # meaningless result a = np.zeros(shape=(1, 80), dtype=np.float64) p = np.inner(a, a) assert_almost_equal(p, 0, decimal=14)
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 class TestInner(TestCase): from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_inner_product_reversed_view
def test_inner_product_reversed_view(self): for dt in np.typecodes["AllInteger"] + np.typecodes["AllFloat"] + "?": # check an inner product involving an aliased and reversed view a = np.arange(5).astype(dt) b = a[::-1] desired = np.array(10, dtype=dt).item() assert_equal(np.inner(b, a), desired)
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 class TestInner(TestCase): from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_3d_tensor
def test_3d_tensor(self): for dt in np.typecodes["AllInteger"] + np.typecodes["AllFloat"] + "?": a = np.arange(24).reshape(2, 3, 4).astype(dt) b = np.arange(24, 48).reshape(2, 3, 4).astype(dt) desired = np.array( [ [ [[158, 182, 206], [230, 254, 278]], [[566, 654, 742], [830, 918, 1006]], [[974, 1126, 1278], [1430, 1582, 1734]], ], [ [[1382, 1598, 1814], [2030, 2246, 2462]], [[1790, 2070, 2350], [2630, 2910, 3190]], [[2198, 2542, 2886], [3230, 3574, 3918]], ], ] ).astype(dt) assert_equal(np.inner(a, b), desired) assert_equal(np.inner(b, a).transpose(2, 3, 0, 1), desired)
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 class TestInner(TestCase): from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_basic
def test_basic(self): sk = np.array([0, -0.1, 0.1]) res = 250 * sk[:, np.newaxis] assert_almost_equal(res.ravel(), 250 * sk)
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 class TestNewaxis(TestCase): from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_broadcast1
def test_broadcast1(self): A = np.choose(self.ind, (self.x2, self.y2)) assert_equal(A, [[2, 2, 3], [2, 2, 3]])
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 @instantiate_parametrized_tests class TestChoose(TestCase): from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_output_dtype
def test_output_dtype(self, ops): expected_dt = np.result_type(*ops) assert np.choose([0], ops).dtype == expected_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 @instantiate_parametrized_tests class TestChoose(TestCase): from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_docstring_1
def test_docstring_1(self): # examples from the docstring, # https://numpy.org/doc/1.23/reference/generated/numpy.choose.html choices = [[0, 1, 2, 3], [10, 11, 12, 13], [20, 21, 22, 23], [30, 31, 32, 33]] A = np.choose([2, 3, 1, 0], choices) assert_equal(A, [20, 31, 12, 3])
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 @instantiate_parametrized_tests class TestChoose(TestCase): from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_docstring_2
def test_docstring_2(self): a = [[1, 0, 1], [0, 1, 0], [1, 0, 1]] choices = [-10, 10] A = np.choose(a, choices) assert_equal(A, [[10, -10, 10], [-10, 10, -10], [10, -10, 10]])
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 @instantiate_parametrized_tests class TestChoose(TestCase): from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_docstring_3
def test_docstring_3(self): a = np.array([0, 1]).reshape((2, 1, 1)) c1 = np.array([1, 2, 3]).reshape((1, 3, 1)) c2 = np.array([-1, -2, -3, -4, -5]).reshape((1, 1, 5)) A = np.choose(a, (c1, c2)) # result is 2x3x5, res[0,:,:]=c1, res[1,:,:]=c2 expected = np.array( [ [[1, 1, 1, 1, 1], [2, 2, 2, 2, 2], [3, 3, 3, 3, 3]], [[-1, -2, -3, -4, -5], [-1, -2, -3, -4, -5], [-1, -2, -3, -4, -5]], ] ) assert_equal(A, 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 @instantiate_parametrized_tests class TestChoose(TestCase): from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_basic
def test_basic(self): sk = np.array([0, -0.1, 0.1]) res = 250 * sk[:, np.newaxis] assert_almost_equal(res.ravel(), 250 * sk)
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 class TestNewaxis(TestCase): from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_broadcast1
def test_broadcast1(self): A = np.choose(self.ind, (self.x2, self.y2)) assert_equal(A, [[2, 2, 3], [2, 2, 3]])
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 @instantiate_parametrized_tests class TestChoose(TestCase): from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_axis_spec
def test_axis_spec(self): A = np.repeat(self.m_rect, [2, 1], axis=0) assert_equal(A, [[1, 2, 3], [1, 2, 3], [4, 5, 6]]) A = np.repeat(self.m_rect, [1, 3, 2], axis=1) assert_equal(A, [[1, 2, 2, 2, 3, 3], [4, 5, 5, 5, 6, 6]])
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 class TestRepeat(TestCase): from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_complex_warning
def test_complex_warning(self): x = np.array([1, 2]) y = np.array([1 - 2j, 1 + 2j]) with warnings.catch_warnings(): warnings.simplefilter("error", np.ComplexWarning) assert_raises(np.ComplexWarning, x.__setitem__, slice(None), y) assert_equal(x, [1, 2])
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} @xpassIfTorchDynamo # (reason="TODO") class TestWarnings(TestCase): from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_usigned_shortshort
def test_usigned_shortshort(self): dt = np.min_scalar_type(2**8 - 1) wanted = np.dtype("uint8") assert_equal(wanted, dt) # three tests below are added based on what numpy does
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} class TestMinScalarType(TestCase): from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_complex
def test_complex(self): dt = np.min_scalar_type(0 + 0j) assert dt == np.dtype("complex64")
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} class TestMinScalarType(TestCase): from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_float
def test_float(self): dt = np.min_scalar_type(0.1) assert dt == np.dtype("float16")
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} class TestMinScalarType(TestCase): from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_nonscalar
def test_nonscalar(self): dt = np.min_scalar_type([0, 1, 2]) assert dt == np.dtype("int64")
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} class TestMinScalarType(TestCase): from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_collections_hashable
def test_collections_hashable(self): x = np.array([]) assert_(not isinstance(x, collections.abc.Hashable))
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 class TestHashing(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_0d
def test_0d(self): a = np.array(np.pi) assert_equal(f"{a:0.3g}", "3.14") assert_equal(f"{a[()]:0.3g}", "3.14")
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 class TestFormat(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_1d_no_format
def test_1d_no_format(self): a = np.array([np.pi]) assert_equal(f"{a}", str(a))
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 class TestFormat(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_1d_format
def test_1d_format(self): # until gh-5543, ensure that the behaviour matches what it used to be a = np.array([np.pi]) assert_raises(TypeError, "{:30}".format, a)
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 class TestFormat(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_argmax_with_out
def test_argmax_with_out(self): mat = np.eye(5) out = np.empty(5, dtype="i2") res = np.argmax(mat, 0, out=out) assert_equal(res, range(5))
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 TestWritebackIfCopy(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_insert_noncontiguous
def test_insert_noncontiguous(self): a = np.arange(6).reshape(2, 3).T # force non-c-contiguous # uses arr_insert np.place(a, a > 2, [44, 55]) assert_equal(a, np.array([[0, 44], [1, 55], [2, 44]])) # hit one of the failing paths assert_raises(ValueError, np.place, a, a > 20, [])
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 TestWritebackIfCopy(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_putmask_noncontiguous
def test_putmask_noncontiguous(self): a = np.arange(6).reshape(2, 3).T # force non-c-contiguous # uses arr_putmask np.putmask(a, a > 2, a**2) assert_equal(a, np.array([[0, 9], [1, 16], [2, 25]]))
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 TestWritebackIfCopy(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_take_mode_raise
def test_take_mode_raise(self): a = np.arange(6, dtype="int") out = np.empty(2, dtype="int") np.take(a, [0, 2], out=out, mode="raise") assert_equal(out, np.array([0, 2]))
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 TestWritebackIfCopy(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_scalar_interface
def test_scalar_interface(self, val, iface, expected): # Test scalar coercion within the array interface self.f.iface = {"typestr": "f8"} self.f.iface.update(iface) if HAS_REFCOUNT: pre_cnt = sys.getrefcount(np.dtype("f8")) if isinstance(expected, type): assert_raises(expected, np.array, val) else: result = np.array(val) assert_equal(np.array(val), expected) assert result.dtype == "f8" del result if HAS_REFCOUNT: post_cnt = sys.getrefcount(np.dtype("f8")) assert_equal(pre_cnt, post_cnt)
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 @skip # not supported, too brittle, too annoying @instantiate_parametrized_tests class TestArrayInterface(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_flat_element_deletion
def test_flat_element_deletion(self): it = np.ones(3).flat try: del it[1] del it[1:2] except TypeError: pass except Exception: raise AssertionError from None
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 class TestDelMisc(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_to_bool_scalar
def test_to_bool_scalar(self): assert_equal(bool(np.array([False])), False) assert_equal(bool(np.array([True])), True) assert_equal(bool(np.array([[42]])), True) assert_raises(ValueError, bool, np.array([1, 2])) class NotConvertible: def __bool__(self): raise NotImplementedError assert_raises(NotImplementedError, bool, np.array(NotConvertible())) assert_raises(NotImplementedError, bool, np.array([NotConvertible()])) if IS_PYSTON: raise SkipTest("Pyston disables recursion checking") self_containing = np.array([None]) self_containing[0] = self_containing Error = RecursionError assert_raises(Error, bool, self_containing) # previously stack overflow self_containing[0] = None # resolve circular reference
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 class TestConversion(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
__bool__
def __bool__(self): raise ValueError # true_vals = [True, np._CopyMode.ALWAYS, np.True_] # false_vals = [False, np._CopyMode.IF_NEEDED, np.False_]
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 class RaiseOnBool: from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_to_int_scalar_2
def test_to_int_scalar_2(self): int_funcs = (int, lambda x: x.__int__()) for int_func in int_funcs: # gh-9972 assert_equal(4, int_func(np.array("4"))) assert_equal(5, int_func(np.bytes_(b"5"))) assert_equal(6, int_func(np.str_("6"))) # The delegation of int() to __trunc__ was deprecated in # Python 3.11. if sys.version_info < (3, 11): class HasTrunc: def __trunc__(self): return 3 assert_equal(3, int_func(np.array(HasTrunc()))) assert_equal(3, int_func(np.array([HasTrunc()]))) else: pass class NotConvertible: def __int__(self): raise NotImplementedError assert_raises(NotImplementedError, int_func, np.array(NotConvertible())) assert_raises(NotImplementedError, int_func, np.array([NotConvertible()]))
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 class TestConversion(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
__trunc__
def __trunc__(self): return 3
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 class HasTrunc: from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
__int__
def __int__(self): raise NotImplementedError
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 class NotConvertible: from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_basic
def test_basic(self): sk = np.array([0, -0.1, 0.1]) res = 250 * sk[:, np.newaxis] assert_almost_equal(res.ravel(), 250 * sk)
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 class TestNewaxis(TestCase): from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
_check
def _check(self, spec, wanted): dt = np.dtype(wanted) actual = _dtype_from_pep3118(spec) assert_equal(actual, dt, err_msg=f"spec {spec!r} != dtype {wanted!r}")
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 @skip(reason="dont worry about buffer protocol") class TestPEP3118Dtype(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_native_padding
def test_native_padding(self): align = np.dtype("i").alignment for j in range(8): if j == 0: s = "bi" else: s = "b%dxi" % j self._check( "@" + s, {"f0": ("i1", 0), "f1": ("i", align * (1 + j // align))} ) self._check("=" + s, {"f0": ("i1", 0), "f1": ("i", 1 + j)})
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 @skip(reason="dont worry about buffer protocol") class TestPEP3118Dtype(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_native_padding_2
def test_native_padding_2(self): # Native padding should work also for structs and sub-arrays self._check("x3T{xi}", {"f0": (({"f0": ("i", 4)}, (3,)), 4)}) self._check("^x3T{xi}", {"f0": (({"f0": ("i", 1)}, (3,)), 1)})
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 @skip(reason="dont worry about buffer protocol") class TestPEP3118Dtype(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_trailing_padding
def test_trailing_padding(self): # Trailing padding should be included, *and*, the item size # should match the alignment if in aligned mode align = np.dtype("i").alignment size = np.dtype("i").itemsize def aligned(n): return align * (1 + (n - 1) // align) base = dict(formats=["i"], names=["f0"]) self._check("ix", dict(itemsize=aligned(size + 1), **base)) self._check("ixx", dict(itemsize=aligned(size + 2), **base)) self._check("ixxx", dict(itemsize=aligned(size + 3), **base)) self._check("ixxxx", dict(itemsize=aligned(size + 4), **base)) self._check("i7x", dict(itemsize=aligned(size + 7), **base)) self._check("^ix", dict(itemsize=size + 1, **base)) self._check("^ixx", dict(itemsize=size + 2, **base)) self._check("^ixxx", dict(itemsize=size + 3, **base)) self._check("^ixxxx", dict(itemsize=size + 4, **base)) self._check("^i7x", dict(itemsize=size + 7, **base))
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 @skip(reason="dont worry about buffer protocol") class TestPEP3118Dtype(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
aligned
def aligned(n): return align * (1 + (n - 1) // align) base = dict(formats=["i"], names=["f0"]) self._check("ix", dict(itemsize=aligned(size + 1), **base)) self._check("ixx", dict(itemsize=aligned(size + 2), **base)) self._check("ixxx", dict(itemsize=aligned(size + 3), **base)) self._check("ixxxx", dict(itemsize=aligned(size + 4), **base)) self._check("i7x", dict(itemsize=aligned(size + 7), **base)) self._check("^ix", dict(itemsize=size + 1, **base)) self._check("^ixx", dict(itemsize=size + 2, **base)) self._check("^ixxx", dict(itemsize=size + 3, **base)) self._check("^ixxxx", dict(itemsize=size + 4, **base)) self._check("^i7x", dict(itemsize=size + 7, **base))
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
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_native_padding_3
def test_native_padding_3(self): dt = np.dtype( [("a", "b"), ("b", "i"), ("sub", np.dtype("b,i")), ("c", "i")], align=True ) self._check("T{b:a:xxxi:b:T{b:f0:=i:f1:}:sub:xxxi:c:}", dt) dt = np.dtype( [ ("a", "b"), ("b", "i"), ("c", "b"), ("d", "b"), ("e", "b"), ("sub", np.dtype("b,i", align=True)), ] ) self._check("T{b:a:=i:b:b:c:b:d:b:e:T{b:f0:xxxi:f1:}:sub:}", 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 @skip(reason="dont worry about buffer protocol") class TestPEP3118Dtype(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_padding_with_array_inside_struct
def test_padding_with_array_inside_struct(self): dt = np.dtype( [("a", "b"), ("b", "i"), ("c", "b", (3,)), ("d", "i")], align=True ) self._check("T{b:a:xxxi:b:3b:c:xi:d:}", 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 @skip(reason="dont worry about buffer protocol") class TestPEP3118Dtype(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_byteorder_inside_struct
def test_byteorder_inside_struct(self): # The byte order after @T{=i} should be '=', not '@'. # Check this by noting the absence of native alignment. self._check("@T{^i}xi", {"f0": ({"f0": ("i", 0)}, 0), "f1": ("i", 5)})
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 @skip(reason="dont worry about buffer protocol") class TestPEP3118Dtype(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_intra_padding
def test_intra_padding(self): # Natively aligned sub-arrays may require some internal padding align = np.dtype("i").alignment size = np.dtype("i").itemsize def aligned(n): return align * (1 + (n - 1) // align) self._check( "(3)T{ix}", ( dict( names=["f0"], formats=["i"], offsets=[0], itemsize=aligned(size + 1) ), (3,), ), )
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 @skip(reason="dont worry about buffer protocol") class TestPEP3118Dtype(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
aligned
def aligned(n): return align * (1 + (n - 1) // align) base = dict(formats=["i"], names=["f0"]) self._check("ix", dict(itemsize=aligned(size + 1), **base)) self._check("ixx", dict(itemsize=aligned(size + 2), **base)) self._check("ixxx", dict(itemsize=aligned(size + 3), **base)) self._check("ixxxx", dict(itemsize=aligned(size + 4), **base)) self._check("i7x", dict(itemsize=aligned(size + 7), **base)) self._check("^ix", dict(itemsize=size + 1, **base)) self._check("^ixx", dict(itemsize=size + 2, **base)) self._check("^ixxx", dict(itemsize=size + 3, **base)) self._check("^ixxxx", dict(itemsize=size + 4, **base)) self._check("^i7x", dict(itemsize=size + 7, **base))
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
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
__array__
def __array__(self, dtype=None): pass
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 class x: from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_order_mismatch
def test_order_mismatch(self, arr, order1, order2): # The order is the main (python side) reason that can cause # a never-copy to fail. # Prepare C-order, F-order and non-contiguous arrays: arr = arr.copy(order1) if order1 == "C": assert arr.flags.c_contiguous elif order1 == "F": assert arr.flags.f_contiguous elif arr.ndim != 0: # Make array non-contiguous arr = arr[::2, ::2] assert not arr.flags.forc # Whether a copy is necessary depends on the order of arr: if order2 == "C": no_copy_necessary = arr.flags.c_contiguous elif order2 == "F": no_copy_necessary = arr.flags.f_contiguous else: # Keeporder and Anyorder are OK with non-contiguous output. # This is not consistent with the `astype` behaviour which # enforces contiguity for "A". It is probably historic from when # "K" did not exist. no_copy_necessary = True # Test it for both the array and a memoryview for view in [arr, memoryview(arr)]: for copy in self.true_vals: res = np.array(view, copy=copy, order=order2) assert res is not arr and res.flags.owndata assert_array_equal(arr, res) if no_copy_necessary: for copy in self.false_vals: res = np.array(view, copy=copy, order=order2) # res.base.obj refers to the memoryview if not IS_PYPY: assert res is arr or res.base.obj is arr res = np.array(view, copy=np._CopyMode.NEVER, order=order2) if not IS_PYPY: assert res is arr or res.base.obj is arr else: for copy in self.false_vals: res = np.array(arr, copy=copy, order=order2) assert_array_equal(arr, res) assert_raises( ValueError, np.array, view, copy=np._CopyMode.NEVER, order=order2 ) assert_raises(ValueError, np.array, view, copy=None, order=order2)
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 @skipif(numpy.__version__ < "1.23", reason="CopyMode is new in NumPy 1.22") @xpassIfTorchDynamo @instantiate_parametrized_tests class TestArrayCreationCopyArgument(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_striding_not_ok
def test_striding_not_ok(self): arr = np.array([[1, 2, 4], [3, 4, 5]]) assert_raises(ValueError, np.array, arr.T, copy=np._CopyMode.NEVER, order="C") assert_raises( ValueError, np.array, arr.T, copy=np._CopyMode.NEVER, order="C", dtype=np.int64, ) assert_raises(ValueError, np.array, arr, copy=np._CopyMode.NEVER, order="F") assert_raises( ValueError, np.array, arr, copy=np._CopyMode.NEVER, order="F", dtype=np.int64, )
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 @skipif(numpy.__version__ < "1.23", reason="CopyMode is new in NumPy 1.22") @xpassIfTorchDynamo @instantiate_parametrized_tests class TestArrayCreationCopyArgument(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_multiarray_writable_attributes_deletion
def test_multiarray_writable_attributes_deletion(self): # ticket #2046, should not seqfault, raise AttributeError a = np.ones(2) attr = ["shape", "strides", "data", "dtype", "real", "imag", "flat"] with suppress_warnings() as sup: sup.filter(DeprecationWarning, "Assigning the 'data' attribute") for s in attr: assert_raises(AttributeError, delattr, a, s)
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 class TestArrayAttributeDeletion(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_multiarray_not_writable_attributes_deletion
def test_multiarray_not_writable_attributes_deletion(self): a = np.ones(2) attr = [ "ndim", "flags", "itemsize", "size", "nbytes", "base", "ctypes", "T", "__array_interface__", "__array_struct__", "__array_priority__", "__array_finalize__", ] for s in attr: assert_raises(AttributeError, delattr, a, s)
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 class TestArrayAttributeDeletion(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_multiarray_flags_writable_attribute_deletion
def test_multiarray_flags_writable_attribute_deletion(self): a = np.ones(2).flags attr = ["writebackifcopy", "updateifcopy", "aligned", "writeable"] for s in attr: assert_raises(AttributeError, delattr, a, s)
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 class TestArrayAttributeDeletion(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_multiarray_flags_not_writable_attribute_deletion
def test_multiarray_flags_not_writable_attribute_deletion(self): a = np.ones(2).flags attr = [ "contiguous", "c_contiguous", "f_contiguous", "fortran", "owndata", "fnc", "forc", "behaved", "carray", "farray", "num", ] for s in attr: assert_raises(AttributeError, delattr, a, s)
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 class TestArrayAttributeDeletion(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
__init__
def __init__(self, arr): self.arr = arr self.__array_interface__ = arr.__array_interface__
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 class Foo: from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
__array_interface__
def __array_interface__(self): return self.iface
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 class Foo: from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_char_vs_string
def test_char_vs_string(self): dt = np.dtype("c") self._check("c", dt) dt = np.dtype([("f0", "S1", (4,)), ("f1", "S4")]) self._check("4c4s", 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 @skip(reason="dont worry about buffer protocol") class TestPEP3118Dtype(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_field_order
def test_field_order(self): # gh-9053 - previously, we relied on dictionary key order self._check("(0)I:a:f:b:", [("a", "I", (0,)), ("b", "f")]) self._check("(0)I:b:f:a:", [("b", "I", (0,)), ("a", "f")])
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 @skip(reason="dont worry about buffer protocol") class TestPEP3118Dtype(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_unnamed_fields
def test_unnamed_fields(self): self._check("ii", [("f0", "i"), ("f1", "i")]) self._check("ii:f0:", [("f1", "i"), ("f0", "i")]) self._check("i", "i") self._check("i:f0:", [("f0", "i")]) # NOTE: xpassIfTorchDynamo below # 1. TODO: torch._numpy does not handle/model _CopyMode # 2. order= keyword not supported (probably won't be) # 3. Under TEST_WITH_TORCHDYNAMO many of these make it through due # to a graph break leaving the _CopyMode to only be handled by numpy.
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 @skip(reason="dont worry about buffer protocol") class TestPEP3118Dtype(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
__bool__
def __bool__(self): raise ValueError # true_vals = [True, np._CopyMode.ALWAYS, np.True_] # false_vals = [False, np._CopyMode.IF_NEEDED, np.False_]
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 class RaiseOnBool: from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_compatible_cast
def test_compatible_cast(self): # Some types are compatible even though they are different, no # copy is necessary for them. This is mostly true for some integers def int_types(byteswap=False): int_types = np.typecodes["Integer"] + np.typecodes["UnsignedInteger"] for int_type in int_types: yield np.dtype(int_type) if byteswap: yield np.dtype(int_type).newbyteorder() for int1 in int_types(): for int2 in int_types(True): arr = np.arange(10, dtype=int1) for copy in self.true_vals: res = np.array(arr, copy=copy, dtype=int2) assert res is not arr and res.flags.owndata assert_array_equal(res, arr) if int1 == int2: # Casting is not necessary, base check is sufficient here for copy in self.false_vals: res = np.array(arr, copy=copy, dtype=int2) assert res is arr or res.base is arr res = np.array(arr, copy=np._CopyMode.NEVER, dtype=int2) assert res is arr or res.base is arr else: # Casting is necessary, assert copy works: for copy in self.false_vals: res = np.array(arr, copy=copy, dtype=int2) assert res is not arr and res.flags.owndata assert_array_equal(res, arr) assert_raises( ValueError, np.array, arr, copy=np._CopyMode.NEVER, dtype=int2 ) assert_raises(ValueError, np.array, arr, copy=None, dtype=int2)
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 @skipif(numpy.__version__ < "1.23", reason="CopyMode is new in NumPy 1.22") @xpassIfTorchDynamo @instantiate_parametrized_tests class TestArrayCreationCopyArgument(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
int_types
def int_types(byteswap=False): int_types = np.typecodes["Integer"] + np.typecodes["UnsignedInteger"] for int_type in int_types: yield np.dtype(int_type) if byteswap: yield np.dtype(int_type).newbyteorder() for int1 in int_types(): for int2 in int_types(True): arr = np.arange(10, dtype=int1) for copy in self.true_vals: res = np.array(arr, copy=copy, dtype=int2) assert res is not arr and res.flags.owndata assert_array_equal(res, arr) if int1 == int2: # Casting is not necessary, base check is sufficient here for copy in self.false_vals: res = np.array(arr, copy=copy, dtype=int2) assert res is arr or res.base is arr res = np.array(arr, copy=np._CopyMode.NEVER, dtype=int2) assert res is arr or res.base is arr else: # Casting is necessary, assert copy works: for copy in self.false_vals: res = np.array(arr, copy=copy, dtype=int2) assert res is not arr and res.flags.owndata assert_array_equal(res, arr) assert_raises( ValueError, np.array, arr, copy=np._CopyMode.NEVER, dtype=int2 ) assert_raises(ValueError, np.array, arr, copy=None, dtype=int2)
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
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_buffer_interface
def test_buffer_interface(self): # Buffer interface gives direct memory access (no copy) arr = np.arange(10) view = memoryview(arr) # Checking bases is a bit tricky since numpy creates another # memoryview, so use may_share_memory. for copy in self.true_vals: res = np.array(view, copy=copy) assert not np.may_share_memory(arr, res) for copy in self.false_vals: res = np.array(view, copy=copy) assert np.may_share_memory(arr, res) res = np.array(view, copy=np._CopyMode.NEVER) assert np.may_share_memory(arr, res)
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 @skipif(numpy.__version__ < "1.23", reason="CopyMode is new in NumPy 1.22") @xpassIfTorchDynamo @instantiate_parametrized_tests class TestArrayCreationCopyArgument(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_array_interfaces
def test_array_interfaces(self): # Array interface gives direct memory access (much like a memoryview) base_arr = np.arange(10) class ArrayLike: __array_interface__ = base_arr.__array_interface__ arr = ArrayLike() for copy, val in [ (True, None), (np._CopyMode.ALWAYS, None), (False, arr), (np._CopyMode.IF_NEEDED, arr), (np._CopyMode.NEVER, arr), ]: res = np.array(arr, copy=copy) assert res.base is val
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 @skipif(numpy.__version__ < "1.23", reason="CopyMode is new in NumPy 1.22") @xpassIfTorchDynamo @instantiate_parametrized_tests class TestArrayCreationCopyArgument(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_exotic_2
def test_exotic_2(self): # object cast d = np.array( [ -1.34, -0.16, -0.54, -0.31, -0.08, -0.95, 0.000, 0.313, 0.547, -0.18, 0.876, 0.236, 1.969, 0.310, 0.699, 1.013, 1.267, 0.229, -1.39, 0.487, ] ) nan = float("NaN") e = np.array( [ "5z", "0l", nan, "Wz", nan, nan, "Xq", "cs", nan, nan, "QN", nan, nan, "Fd", nan, nan, "kp", nan, "36", "i1", ], dtype=object, ) m = np.array( [0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0], dtype=bool ) r = e[:] r[np.where(m)] = d[np.where(m)] assert_array_equal(np.where(m, d, e), r) r = e[:] r[np.where(~m)] = d[np.where(~m)] assert_array_equal(np.where(m, e, d), r) assert_array_equal(np.where(m, e, e), e) # minimal dtype result with NaN scalar (e.g required by pandas) d = np.array([1.0, 2.0], dtype=np.float32) e = float("NaN") assert_equal(np.where(True, d, e).dtype, np.float32) e = float("Infinity") assert_equal(np.where(True, d, e).dtype, np.float32) e = float("-Infinity") assert_equal(np.where(True, d, e).dtype, np.float32) # also check upcast e = 1e150 assert_equal(np.where(True, d, e).dtype, np.float64)
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 class TestWhere(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_ndim
def test_ndim(self): c = [True, False] a = np.zeros((2, 25)) b = np.ones((2, 25)) r = np.where(np.array(c)[:, np.newaxis], a, b) assert_array_equal(r[0], a[0]) assert_array_equal(r[1], b[0]) a = a.T b = b.T r = np.where(c, a, b) assert_array_equal(r[:, 0], a[:, 0]) assert_array_equal(r[:, 1], b[:, 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 class TestWhere(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_foreign
def test_foreign(self): c = np.array( [ False, True, False, False, False, False, True, False, False, False, True, False, ] ) r = np.array( [5.0, 1.0, 3.0, 2.0, -1.0, -4.0, 1.0, -10.0, 10.0, 1.0, 1.0, 3.0], dtype=np.float64, ) a = np.ones(1, dtype=">i4") b = np.array( [5.0, 0.0, 3.0, 2.0, -1.0, -4.0, 0.0, -10.0, 10.0, 1.0, 0.0, 3.0], dtype=np.float64, ) assert_equal(np.where(c, a, b), r) b = b.astype(">f8") assert_equal(np.where(c, a, b), r) a = a.astype("<i4") assert_equal(np.where(c, a, b), r) c = c.astype(">i4") assert_equal(np.where(c, a, b), r)
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 class TestWhere(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_error
def test_error(self): c = [True, True] a = np.ones((4, 5)) b = np.ones((5, 5)) assert_raises((RuntimeError, ValueError), np.where, c, a, a) assert_raises((RuntimeError, ValueError), np.where, c[0], a, b)
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 class TestWhere(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_empty_result
def test_empty_result(self): # pass empty where result through an assignment which reads the data of # empty arrays, error detectable with valgrind, see gh-8922 x = np.zeros((1, 1)) ibad = np.vstack(np.where(x == 99.0)) assert_array_equal(ibad, np.atleast_2d(np.array([[], []], dtype=np.intp)))
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 class TestWhere(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_largedim
def test_largedim(self): # invalid read regression gh-9304 shape = [10, 2, 3, 4, 5, 6] np.random.seed(2) array = np.random.rand(*shape) for i in range(10): benchmark = array.nonzero() result = array.nonzero() assert_array_equal(benchmark, result)
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 class TestWhere(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_kwargs
def test_kwargs(self): x = np.array([0, 0]) np.putmask(x, [0, 1], [-1, -2]) assert_array_equal(x, [0, -2]) x = np.array([0, 0]) np.putmask(x, mask=[0, 1], values=[-1, -2]) assert_array_equal(x, [0, -2]) x = np.array([0, 0]) np.putmask(x, values=[-1, -2], mask=[0, 1]) assert_array_equal(x, [0, -2]) with pytest.raises(TypeError): np.putmask(a=x, values=[-1, -2], mask=[0, 1])
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 []), } @xpassIfTorchDynamo # (reason="TODO") @instantiate_parametrized_tests class TestPutmask(TestCase): from numpy.core.multiarray import dot from numpy.core.multiarray import dot from numpy.core.multiarray import dot import operator from numpy.core._internal import _dtype_from_pep3118 from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_arrays_not_hashable
def test_arrays_not_hashable(self): x = np.ones(3) assert_raises(TypeError, hash, x)
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 class TestHashing(TestCase): from numpy.testing import IS_PYPY
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_flatiter__array__
def test_flatiter__array__(self): a = np.arange(9).reshape(3, 3) b = a.T.flat c = b.__array__() # triggers the WRITEBACKIFCOPY resolution, assuming refcount semantics del c
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 TestWritebackIfCopy(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added
torch
test/torch_np/numpy_tests/core/test_multiarray.py
test_dot_out
def test_dot_out(self): # if HAVE_CBLAS, will use WRITEBACKIFCOPY a = np.arange(9, dtype=float).reshape(3, 3) b = np.dot(a, a, out=a) assert_equal(b, np.array([[15, 18, 21], [42, 54, 66], [69, 90, 111]]))
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 TestWritebackIfCopy(TestCase):
c263bd43e8e8502d4726643bc6fd046f0130ac0e
32f585d9346e316e554c8d9bf7548af9f62141fc
added