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
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.