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