summaryrefslogtreecommitdiff
path: root/numpy/array_api/tests
diff options
context:
space:
mode:
authorAaron Meurer <asmeurer@gmail.com>2021-08-06 18:22:00 -0600
committerAaron Meurer <asmeurer@gmail.com>2021-08-06 18:23:04 -0600
commit8f7d00ed447174d9398af3365709222b529c1cad (patch)
tree9de0a3a757a8c8a7393787ee1449e087c284d6e1 /numpy/array_api/tests
parent21923a5fa71bfadf7dee0bb5b110cc2a5719eaac (diff)
downloadnumpy-8f7d00ed447174d9398af3365709222b529c1cad.tar.gz
Run (selective) black on the array_api submodule
I've omitted a few changes from black that messed up the readability of some complicated if statements that were organized logically line-by-line, and some changes that use unnecessary operator spacing.
Diffstat (limited to 'numpy/array_api/tests')
-rw-r--r--numpy/array_api/tests/test_array_object.py101
-rw-r--r--numpy/array_api/tests/test_creation_functions.py122
-rw-r--r--numpy/array_api/tests/test_elementwise_functions.py133
3 files changed, 212 insertions, 144 deletions
diff --git a/numpy/array_api/tests/test_array_object.py b/numpy/array_api/tests/test_array_object.py
index 22078bbee..088e09b9f 100644
--- a/numpy/array_api/tests/test_array_object.py
+++ b/numpy/array_api/tests/test_array_object.py
@@ -2,9 +2,20 @@ from numpy.testing import assert_raises
import numpy as np
from .. import ones, asarray, result_type
-from .._dtypes import (_all_dtypes, _boolean_dtypes, _floating_dtypes,
- _integer_dtypes, _integer_or_boolean_dtypes,
- _numeric_dtypes, int8, int16, int32, int64, uint64)
+from .._dtypes import (
+ _all_dtypes,
+ _boolean_dtypes,
+ _floating_dtypes,
+ _integer_dtypes,
+ _integer_or_boolean_dtypes,
+ _numeric_dtypes,
+ int8,
+ int16,
+ int32,
+ int64,
+ uint64,
+)
+
def test_validate_index():
# The indexing tests in the official array API test suite test that the
@@ -61,28 +72,29 @@ def test_validate_index():
assert_raises(IndexError, lambda: a[None, ...])
assert_raises(IndexError, lambda: a[..., None])
+
def test_operators():
# For every operator, we test that it works for the required type
# combinations and raises TypeError otherwise
- binary_op_dtypes ={
- '__add__': 'numeric',
- '__and__': 'integer_or_boolean',
- '__eq__': 'all',
- '__floordiv__': 'numeric',
- '__ge__': 'numeric',
- '__gt__': 'numeric',
- '__le__': 'numeric',
- '__lshift__': 'integer',
- '__lt__': 'numeric',
- '__mod__': 'numeric',
- '__mul__': 'numeric',
- '__ne__': 'all',
- '__or__': 'integer_or_boolean',
- '__pow__': 'floating',
- '__rshift__': 'integer',
- '__sub__': 'numeric',
- '__truediv__': 'floating',
- '__xor__': 'integer_or_boolean',
+ binary_op_dtypes = {
+ "__add__": "numeric",
+ "__and__": "integer_or_boolean",
+ "__eq__": "all",
+ "__floordiv__": "numeric",
+ "__ge__": "numeric",
+ "__gt__": "numeric",
+ "__le__": "numeric",
+ "__lshift__": "integer",
+ "__lt__": "numeric",
+ "__mod__": "numeric",
+ "__mul__": "numeric",
+ "__ne__": "all",
+ "__or__": "integer_or_boolean",
+ "__pow__": "floating",
+ "__rshift__": "integer",
+ "__sub__": "numeric",
+ "__truediv__": "floating",
+ "__xor__": "integer_or_boolean",
}
# Recompute each time because of in-place ops
@@ -92,15 +104,15 @@ def test_operators():
for d in _boolean_dtypes:
yield asarray(False, dtype=d)
for d in _floating_dtypes:
- yield asarray(1., dtype=d)
+ yield asarray(1.0, dtype=d)
for op, dtypes in binary_op_dtypes.items():
ops = [op]
- if op not in ['__eq__', '__ne__', '__le__', '__ge__', '__lt__', '__gt__']:
- rop = '__r' + op[2:]
- iop = '__i' + op[2:]
+ if op not in ["__eq__", "__ne__", "__le__", "__ge__", "__lt__", "__gt__"]:
+ rop = "__r" + op[2:]
+ iop = "__i" + op[2:]
ops += [rop, iop]
- for s in [1, 1., False]:
+ for s in [1, 1.0, False]:
for _op in ops:
for a in _array_vals():
# Test array op scalar. From the spec, the following combinations
@@ -149,7 +161,10 @@ def test_operators():
):
assert_raises(TypeError, lambda: getattr(x, _op)(y))
# Ensure in-place operators only promote to the same dtype as the left operand.
- elif _op.startswith('__i') and result_type(x.dtype, y.dtype) != x.dtype:
+ elif (
+ _op.startswith("__i")
+ and result_type(x.dtype, y.dtype) != x.dtype
+ ):
assert_raises(TypeError, lambda: getattr(x, _op)(y))
# Ensure only those dtypes that are required for every operator are allowed.
elif (dtypes == "all" and (x.dtype in _boolean_dtypes and y.dtype in _boolean_dtypes
@@ -165,17 +180,20 @@ def test_operators():
else:
assert_raises(TypeError, lambda: getattr(x, _op)(y))
- unary_op_dtypes ={
- '__abs__': 'numeric',
- '__invert__': 'integer_or_boolean',
- '__neg__': 'numeric',
- '__pos__': 'numeric',
+ unary_op_dtypes = {
+ "__abs__": "numeric",
+ "__invert__": "integer_or_boolean",
+ "__neg__": "numeric",
+ "__pos__": "numeric",
}
for op, dtypes in unary_op_dtypes.items():
for a in _array_vals():
- if (dtypes == "numeric" and a.dtype in _numeric_dtypes
- or dtypes == "integer_or_boolean" and a.dtype in _integer_or_boolean_dtypes
- ):
+ if (
+ dtypes == "numeric"
+ and a.dtype in _numeric_dtypes
+ or dtypes == "integer_or_boolean"
+ and a.dtype in _integer_or_boolean_dtypes
+ ):
# Only test for no error
getattr(a, op)()
else:
@@ -192,8 +210,8 @@ def test_operators():
yield ones((4, 4), dtype=d)
# Scalars always error
- for _op in ['__matmul__', '__rmatmul__', '__imatmul__']:
- for s in [1, 1., False]:
+ for _op in ["__matmul__", "__rmatmul__", "__imatmul__"]:
+ for s in [1, 1.0, False]:
for a in _matmul_array_vals():
if (type(s) in [float, int] and a.dtype in _floating_dtypes
or type(s) == int and a.dtype in _integer_dtypes):
@@ -235,16 +253,17 @@ def test_operators():
else:
x.__imatmul__(y)
+
def test_python_scalar_construtors():
a = asarray(False)
b = asarray(0)
- c = asarray(0.)
+ c = asarray(0.0)
assert bool(a) == bool(b) == bool(c) == False
assert int(a) == int(b) == int(c) == 0
- assert float(a) == float(b) == float(c) == 0.
+ assert float(a) == float(b) == float(c) == 0.0
# bool/int/float should only be allowed on 0-D arrays.
assert_raises(TypeError, lambda: bool(asarray([False])))
assert_raises(TypeError, lambda: int(asarray([0])))
- assert_raises(TypeError, lambda: float(asarray([0.])))
+ assert_raises(TypeError, lambda: float(asarray([0.0])))
diff --git a/numpy/array_api/tests/test_creation_functions.py b/numpy/array_api/tests/test_creation_functions.py
index 654f1d9b3..3cb8865cd 100644
--- a/numpy/array_api/tests/test_creation_functions.py
+++ b/numpy/array_api/tests/test_creation_functions.py
@@ -2,26 +2,53 @@ from numpy.testing import assert_raises
import numpy as np
from .. import all
-from .._creation_functions import (asarray, arange, empty, empty_like, eye, from_dlpack, full, full_like, linspace, meshgrid, ones, ones_like, zeros, zeros_like)
+from .._creation_functions import (
+ asarray,
+ arange,
+ empty,
+ empty_like,
+ eye,
+ from_dlpack,
+ full,
+ full_like,
+ linspace,
+ meshgrid,
+ ones,
+ ones_like,
+ zeros,
+ zeros_like,
+)
from .._array_object import Array
-from .._dtypes import (_all_dtypes, _boolean_dtypes, _floating_dtypes,
- _integer_dtypes, _integer_or_boolean_dtypes,
- _numeric_dtypes, int8, int16, int32, int64, uint64)
+from .._dtypes import (
+ _all_dtypes,
+ _boolean_dtypes,
+ _floating_dtypes,
+ _integer_dtypes,
+ _integer_or_boolean_dtypes,
+ _numeric_dtypes,
+ int8,
+ int16,
+ int32,
+ int64,
+ uint64,
+)
+
def test_asarray_errors():
# Test various protections against incorrect usage
assert_raises(TypeError, lambda: Array([1]))
- assert_raises(TypeError, lambda: asarray(['a']))
- assert_raises(ValueError, lambda: asarray([1.], dtype=np.float16))
+ assert_raises(TypeError, lambda: asarray(["a"]))
+ assert_raises(ValueError, lambda: asarray([1.0], dtype=np.float16))
assert_raises(OverflowError, lambda: asarray(2**100))
# Preferably this would be OverflowError
# assert_raises(OverflowError, lambda: asarray([2**100]))
assert_raises(TypeError, lambda: asarray([2**100]))
- asarray([1], device='cpu') # Doesn't error
- assert_raises(ValueError, lambda: asarray([1], device='gpu'))
+ asarray([1], device="cpu") # Doesn't error
+ assert_raises(ValueError, lambda: asarray([1], device="gpu"))
assert_raises(ValueError, lambda: asarray([1], dtype=int))
- assert_raises(ValueError, lambda: asarray([1], dtype='i'))
+ assert_raises(ValueError, lambda: asarray([1], dtype="i"))
+
def test_asarray_copy():
a = asarray([1])
@@ -36,68 +63,79 @@ def test_asarray_copy():
# assert all(b[0] == 0)
assert_raises(NotImplementedError, lambda: asarray(a, copy=False))
+
def test_arange_errors():
- arange(1, device='cpu') # Doesn't error
- assert_raises(ValueError, lambda: arange(1, device='gpu'))
+ arange(1, device="cpu") # Doesn't error
+ assert_raises(ValueError, lambda: arange(1, device="gpu"))
assert_raises(ValueError, lambda: arange(1, dtype=int))
- assert_raises(ValueError, lambda: arange(1, dtype='i'))
+ assert_raises(ValueError, lambda: arange(1, dtype="i"))
+
def test_empty_errors():
- empty((1,), device='cpu') # Doesn't error
- assert_raises(ValueError, lambda: empty((1,), device='gpu'))
+ empty((1,), device="cpu") # Doesn't error
+ assert_raises(ValueError, lambda: empty((1,), device="gpu"))
assert_raises(ValueError, lambda: empty((1,), dtype=int))
- assert_raises(ValueError, lambda: empty((1,), dtype='i'))
+ assert_raises(ValueError, lambda: empty((1,), dtype="i"))
+
def test_empty_like_errors():
- empty_like(asarray(1), device='cpu') # Doesn't error
- assert_raises(ValueError, lambda: empty_like(asarray(1), device='gpu'))
+ empty_like(asarray(1), device="cpu") # Doesn't error
+ assert_raises(ValueError, lambda: empty_like(asarray(1), device="gpu"))
assert_raises(ValueError, lambda: empty_like(asarray(1), dtype=int))
- assert_raises(ValueError, lambda: empty_like(asarray(1), dtype='i'))
+ assert_raises(ValueError, lambda: empty_like(asarray(1), dtype="i"))
+
def test_eye_errors():
- eye(1, device='cpu') # Doesn't error
- assert_raises(ValueError, lambda: eye(1, device='gpu'))
+ eye(1, device="cpu") # Doesn't error
+ assert_raises(ValueError, lambda: eye(1, device="gpu"))
assert_raises(ValueError, lambda: eye(1, dtype=int))
- assert_raises(ValueError, lambda: eye(1, dtype='i'))
+ assert_raises(ValueError, lambda: eye(1, dtype="i"))
+
def test_full_errors():
- full((1,), 0, device='cpu') # Doesn't error
- assert_raises(ValueError, lambda: full((1,), 0, device='gpu'))
+ full((1,), 0, device="cpu") # Doesn't error
+ assert_raises(ValueError, lambda: full((1,), 0, device="gpu"))
assert_raises(ValueError, lambda: full((1,), 0, dtype=int))
- assert_raises(ValueError, lambda: full((1,), 0, dtype='i'))
+ assert_raises(ValueError, lambda: full((1,), 0, dtype="i"))
+
def test_full_like_errors():
- full_like(asarray(1), 0, device='cpu') # Doesn't error
- assert_raises(ValueError, lambda: full_like(asarray(1), 0, device='gpu'))
+ full_like(asarray(1), 0, device="cpu") # Doesn't error
+ assert_raises(ValueError, lambda: full_like(asarray(1), 0, device="gpu"))
assert_raises(ValueError, lambda: full_like(asarray(1), 0, dtype=int))
- assert_raises(ValueError, lambda: full_like(asarray(1), 0, dtype='i'))
+ assert_raises(ValueError, lambda: full_like(asarray(1), 0, dtype="i"))
+
def test_linspace_errors():
- linspace(0, 1, 10, device='cpu') # Doesn't error
- assert_raises(ValueError, lambda: linspace(0, 1, 10, device='gpu'))
+ linspace(0, 1, 10, device="cpu") # Doesn't error
+ assert_raises(ValueError, lambda: linspace(0, 1, 10, device="gpu"))
assert_raises(ValueError, lambda: linspace(0, 1, 10, dtype=float))
- assert_raises(ValueError, lambda: linspace(0, 1, 10, dtype='f'))
+ assert_raises(ValueError, lambda: linspace(0, 1, 10, dtype="f"))
+
def test_ones_errors():
- ones((1,), device='cpu') # Doesn't error
- assert_raises(ValueError, lambda: ones((1,), device='gpu'))
+ ones((1,), device="cpu") # Doesn't error
+ assert_raises(ValueError, lambda: ones((1,), device="gpu"))
assert_raises(ValueError, lambda: ones((1,), dtype=int))
- assert_raises(ValueError, lambda: ones((1,), dtype='i'))
+ assert_raises(ValueError, lambda: ones((1,), dtype="i"))
+
def test_ones_like_errors():
- ones_like(asarray(1), device='cpu') # Doesn't error
- assert_raises(ValueError, lambda: ones_like(asarray(1), device='gpu'))
+ ones_like(asarray(1), device="cpu") # Doesn't error
+ assert_raises(ValueError, lambda: ones_like(asarray(1), device="gpu"))
assert_raises(ValueError, lambda: ones_like(asarray(1), dtype=int))
- assert_raises(ValueError, lambda: ones_like(asarray(1), dtype='i'))
+ assert_raises(ValueError, lambda: ones_like(asarray(1), dtype="i"))
+
def test_zeros_errors():
- zeros((1,), device='cpu') # Doesn't error
- assert_raises(ValueError, lambda: zeros((1,), device='gpu'))
+ zeros((1,), device="cpu") # Doesn't error
+ assert_raises(ValueError, lambda: zeros((1,), device="gpu"))
assert_raises(ValueError, lambda: zeros((1,), dtype=int))
- assert_raises(ValueError, lambda: zeros((1,), dtype='i'))
+ assert_raises(ValueError, lambda: zeros((1,), dtype="i"))
+
def test_zeros_like_errors():
- zeros_like(asarray(1), device='cpu') # Doesn't error
- assert_raises(ValueError, lambda: zeros_like(asarray(1), device='gpu'))
+ zeros_like(asarray(1), device="cpu") # Doesn't error
+ assert_raises(ValueError, lambda: zeros_like(asarray(1), device="gpu"))
assert_raises(ValueError, lambda: zeros_like(asarray(1), dtype=int))
- assert_raises(ValueError, lambda: zeros_like(asarray(1), dtype='i'))
+ assert_raises(ValueError, lambda: zeros_like(asarray(1), dtype="i"))
diff --git a/numpy/array_api/tests/test_elementwise_functions.py b/numpy/array_api/tests/test_elementwise_functions.py
index ec76cb7a7..a9274aec9 100644
--- a/numpy/array_api/tests/test_elementwise_functions.py
+++ b/numpy/array_api/tests/test_elementwise_functions.py
@@ -4,74 +4,80 @@ from numpy.testing import assert_raises
from .. import asarray, _elementwise_functions
from .._elementwise_functions import bitwise_left_shift, bitwise_right_shift
-from .._dtypes import (_dtype_categories, _boolean_dtypes, _floating_dtypes,
- _integer_dtypes)
+from .._dtypes import (
+ _dtype_categories,
+ _boolean_dtypes,
+ _floating_dtypes,
+ _integer_dtypes,
+)
+
def nargs(func):
return len(getfullargspec(func).args)
+
def test_function_types():
# Test that every function accepts only the required input types. We only
# test the negative cases here (error). The positive cases are tested in
# the array API test suite.
elementwise_function_input_types = {
- 'abs': 'numeric',
- 'acos': 'floating-point',
- 'acosh': 'floating-point',
- 'add': 'numeric',
- 'asin': 'floating-point',
- 'asinh': 'floating-point',
- 'atan': 'floating-point',
- 'atan2': 'floating-point',
- 'atanh': 'floating-point',
- 'bitwise_and': 'integer or boolean',
- 'bitwise_invert': 'integer or boolean',
- 'bitwise_left_shift': 'integer',
- 'bitwise_or': 'integer or boolean',
- 'bitwise_right_shift': 'integer',
- 'bitwise_xor': 'integer or boolean',
- 'ceil': 'numeric',
- 'cos': 'floating-point',
- 'cosh': 'floating-point',
- 'divide': 'floating-point',
- 'equal': 'all',
- 'exp': 'floating-point',
- 'expm1': 'floating-point',
- 'floor': 'numeric',
- 'floor_divide': 'numeric',
- 'greater': 'numeric',
- 'greater_equal': 'numeric',
- 'isfinite': 'numeric',
- 'isinf': 'numeric',
- 'isnan': 'numeric',
- 'less': 'numeric',
- 'less_equal': 'numeric',
- 'log': 'floating-point',
- 'logaddexp': 'floating-point',
- 'log10': 'floating-point',
- 'log1p': 'floating-point',
- 'log2': 'floating-point',
- 'logical_and': 'boolean',
- 'logical_not': 'boolean',
- 'logical_or': 'boolean',
- 'logical_xor': 'boolean',
- 'multiply': 'numeric',
- 'negative': 'numeric',
- 'not_equal': 'all',
- 'positive': 'numeric',
- 'pow': 'floating-point',
- 'remainder': 'numeric',
- 'round': 'numeric',
- 'sign': 'numeric',
- 'sin': 'floating-point',
- 'sinh': 'floating-point',
- 'sqrt': 'floating-point',
- 'square': 'numeric',
- 'subtract': 'numeric',
- 'tan': 'floating-point',
- 'tanh': 'floating-point',
- 'trunc': 'numeric',
+ "abs": "numeric",
+ "acos": "floating-point",
+ "acosh": "floating-point",
+ "add": "numeric",
+ "asin": "floating-point",
+ "asinh": "floating-point",
+ "atan": "floating-point",
+ "atan2": "floating-point",
+ "atanh": "floating-point",
+ "bitwise_and": "integer or boolean",
+ "bitwise_invert": "integer or boolean",
+ "bitwise_left_shift": "integer",
+ "bitwise_or": "integer or boolean",
+ "bitwise_right_shift": "integer",
+ "bitwise_xor": "integer or boolean",
+ "ceil": "numeric",
+ "cos": "floating-point",
+ "cosh": "floating-point",
+ "divide": "floating-point",
+ "equal": "all",
+ "exp": "floating-point",
+ "expm1": "floating-point",
+ "floor": "numeric",
+ "floor_divide": "numeric",
+ "greater": "numeric",
+ "greater_equal": "numeric",
+ "isfinite": "numeric",
+ "isinf": "numeric",
+ "isnan": "numeric",
+ "less": "numeric",
+ "less_equal": "numeric",
+ "log": "floating-point",
+ "logaddexp": "floating-point",
+ "log10": "floating-point",
+ "log1p": "floating-point",
+ "log2": "floating-point",
+ "logical_and": "boolean",
+ "logical_not": "boolean",
+ "logical_or": "boolean",
+ "logical_xor": "boolean",
+ "multiply": "numeric",
+ "negative": "numeric",
+ "not_equal": "all",
+ "positive": "numeric",
+ "pow": "floating-point",
+ "remainder": "numeric",
+ "round": "numeric",
+ "sign": "numeric",
+ "sin": "floating-point",
+ "sinh": "floating-point",
+ "sqrt": "floating-point",
+ "square": "numeric",
+ "subtract": "numeric",
+ "tan": "floating-point",
+ "tanh": "floating-point",
+ "trunc": "numeric",
}
def _array_vals():
@@ -80,7 +86,7 @@ def test_function_types():
for d in _boolean_dtypes:
yield asarray(False, dtype=d)
for d in _floating_dtypes:
- yield asarray(1., dtype=d)
+ yield asarray(1.0, dtype=d)
for x in _array_vals():
for func_name, types in elementwise_function_input_types.items():
@@ -94,7 +100,12 @@ def test_function_types():
if x.dtype not in dtypes:
assert_raises(TypeError, lambda: func(x))
+
def test_bitwise_shift_error():
# bitwise shift functions should raise when the second argument is negative
- assert_raises(ValueError, lambda: bitwise_left_shift(asarray([1, 1]), asarray([1, -1])))
- assert_raises(ValueError, lambda: bitwise_right_shift(asarray([1, 1]), asarray([1, -1])))
+ assert_raises(
+ ValueError, lambda: bitwise_left_shift(asarray([1, 1]), asarray([1, -1]))
+ )
+ assert_raises(
+ ValueError, lambda: bitwise_right_shift(asarray([1, 1]), asarray([1, -1]))
+ )