NumPy version 1.21.4 NumPy relaxed strides checking option: True NumPy CPU features: SSE SSE2 SSE3 SSSE3* SSE41* POPCNT* SSE42* AVX* F16C? FMA3? AVX2* AVX512F? AVX512CD? AVX512_KNL? AVX512_SKX? AVX512_CLX? AVX512_CNL? AVX512_ICL? ........................................................................ [ 0%] ..............................................................x......... [ 0%] ........................................................................ [ 1%] ........................................................x............... [ 1%] ........................................................................ [ 2%] ........................................................................ [ 2%] ........................................................................ [ 3%] .........................................................Fsss........... [ 3%] ........................................................................ [ 4%] ........................................................................ [ 4%] ........................................................................ [ 5%] x..........x..x..........x.............................................. [ 5%] ........................................................................ [ 5%] ........................................................................ [ 6%] ...................................................................ssss. [ 6%] ........................................................................ [ 7%] ........................................................................ [ 7%] ........................................................................ [ 8%] ........................................................................ [ 8%] ........................................................................ [ 9%] ........................................................................ [ 9%] ........................................................................ [ 10%] ........................................................................ [ 10%] ........................................................................ [ 11%] ........................................................................ [ 11%] ........................................................................ [ 11%] ........................................................................ [ 12%] ........................................................................ [ 12%] ........................................................................ [ 13%] ........................................................................ [ 13%] ....................................sss................................. [ 14%] ........................................................................ [ 14%] .................................................xx..................... [ 15%] ........................................................................ [ 15%] ....................................s................................... [ 16%] ........................................................................ [ 16%] ........................................................................ [ 17%] ........................................................................ [ 17%] ........................................................................ [ 17%] ........................................................................ [ 18%] ........................................................................ [ 18%] ................................F.F.....F.F.....................F.F..... [ 19%] F.F.....................F.F.....F.F..................................... [ 19%] ........................................................................ [ 20%] ........................................................................ [ 20%] ........................................................................ [ 21%] ........................................................................ [ 21%] ........................................................................ [ 22%] ........................................................................ [ 22%] ........................................................................ [ 23%] ........................................................................ [ 23%] ........................................................................ [ 23%] ........................................................................ [ 24%] ........................................................................ [ 24%] ...........x...x........................................................ [ 25%] ........................................................................ [ 25%] ..........................................................xx............ [ 26%] ........................................................................ [ 26%] ........................................................................ [ 27%] ........................................................................ [ 27%] ........................................................................ [ 28%] ........................................................................ [ 28%] ........................................................................ [ 29%] ........................................................................ [ 29%] ........................................................................ [ 29%] ........................................................................ [ 30%] ........................................................................ [ 30%] ........................................................................ [ 31%] ........................................................................ [ 31%] ........................................................................ [ 32%] ........................................................................ [ 32%] ..........................................F..................s.......... [ 33%] ........................................................................ [ 33%] ...........................s............................................ [ 34%] ........................................................................ [ 34%] .................................................................sssssss [ 35%] ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss [ 35%] ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss [ 35%] ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss [ 36%] ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss [ 36%] ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss [ 37%] ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss [ 37%] ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss [ 38%] ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss [ 38%] ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss [ 39%] ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss [ 39%] ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss [ 40%] sssssssssss............................................................. [ 40%] ........................................................................ [ 40%] ........................................................................ [ 41%] ........................................................................ [ 41%] ........................................................................ [ 42%] ........................................................................ [ 42%] ........................................................................ [ 43%] ........................................................................ [ 43%] ..................................................................F..... [ 44%] ........................................................................ [ 44%] ........................................................................ [ 45%] ........................................................................ [ 45%] ........................................................................ [ 46%] ........................................................................ [ 46%] ........................................................................ [ 46%] .......................F................................................ [ 47%] ssssssssssssF........................................................... [ 47%] ........................................................................ [ 48%] ....................s.ss.s..s.......s...FF....FF........................ [ 48%] ........................................................................ [ 49%] ........................................................................ [ 49%] ........................................................................ [ 50%] ........................................................................ [ 50%] ........................................................................ [ 51%] ........................................................................ [ 51%] ........................................................................ [ 52%] ........................................................................ [ 52%] ..........................................s...........sssssssssssssss... [ 52%] ............sssssssssssssss............................................. [ 53%] ........................................................................ [ 53%] ........................................................................ [ 54%] ........................................................................ [ 54%] ........................................................................ [ 55%] ........................................................................ [ 55%] ........................................................................ [ 56%] ........................................................................ [ 56%] ........................................................................ [ 57%] ........................................................................ [ 57%] ........................................................................ [ 58%] ........................................................................ [ 58%] ................x....................................................... [ 58%] ........................................................................ [ 59%] ........................................................................ [ 59%] ........................................................................ [ 60%] ........................................................................ [ 60%] ........................................................................ [ 61%] ........................................................................ [ 61%] ........................................................................ [ 62%] ........................................................................ [ 62%] ........................................................................ [ 63%] .........................x.............................................. [ 63%] ........................................................................ [ 64%] ........................................................................ [ 64%] ........................................................................ [ 64%] ........................................................................ [ 65%] ........................................................................ [ 65%] ........................................................................ [ 66%] ........................................................................ [ 66%] ........................................................................ [ 67%] ........................................................................ [ 67%] ........................................................................ [ 68%] ........................................................................ [ 68%] ........................................................................ [ 69%] ........................................................x............... [ 69%] ........................................................................ [ 70%] ........................................................................ [ 70%] ........................................................................ [ 70%] ....s...............................................x................... [ 71%] ........................................................................ [ 71%] ........................................................................ [ 72%] .......................F.F.......F.........F.F.......................... [ 72%] ............x........................................................... [ 73%] ........................................................................ [ 73%] ........................................................................ [ 74%] ........................................................................ [ 74%] ........................................................................ [ 75%] ........................................................................ [ 75%] ........................................................................ [ 75%] ........................................................................ [ 76%] ........................................................................ [ 76%] ........................................................................ [ 77%] ........................................................................ [ 77%] ........................................................................ [ 78%] ........................................................................ [ 78%] ........................................................................ [ 79%] ........................................................................ [ 79%] ........................................................................ [ 80%] ........................................................................ [ 80%] ........................................................................ [ 81%] ........................................................................ [ 81%] ........................................................................ [ 81%] ...............xx....................................................... [ 82%] ........................................................................ [ 82%] ........................................................................ [ 83%] ........................................................................ [ 83%] ........................................................................ [ 84%] ........................................................................ [ 84%] ........................................................................ [ 85%] ........................................................................ [ 85%] ........................................................................ [ 86%] ........................................................................ [ 86%] ........................................................................ [ 87%] ........................................................................ [ 87%] ........................................................................ [ 87%] ........................................................................ [ 88%] ........................................................................ [ 88%] ........................................................................ [ 89%] ........................................................................ [ 89%] ....................s................................................... [ 90%] ........................................................................ [ 90%] ........................................................................ [ 91%] ........................................................................ [ 91%] ........................................................................ [ 92%] ........................................................................ [ 92%] ........................................................................ [ 93%] ........................................................................ [ 93%] ........................................................................ [ 93%] ............s........................................................... [ 94%] ........................................................................ [ 94%] ........................................................................ [ 95%] ........................................................................ [ 95%] ...............ss....................................................... [ 96%] ........................................................................ [ 96%] ........................................................................ [ 97%] ........................................................................ [ 97%] .................................................................sss.... [ 98%] ........................................................................ [ 98%] .............XXX........................................................ [ 99%] ........................................................................ [ 99%] ........................................................................ [ 99%] ......... [100%] =================================== FAILURES =================================== _______________________________ test_dispatcher ________________________________ def test_dispatcher(): """ Testing the utilites of the CPU dispatcher """ targets = ( "SSE2", "SSE41", "AVX2", "VSX", "VSX2", "VSX3", "NEON", "ASIMD", "ASIMDHP" ) highest_sfx = "" # no suffix for the baseline all_sfx = [] for feature in reversed(targets): # skip baseline features, by the default `CCompilerOpt` do not generate separated objects # for the baseline, just one object combined all of them via 'baseline' option # within the configuration statments. if feature in __cpu_baseline__: continue # check compiler and running machine support if feature not in __cpu_dispatch__ or not __cpu_features__[feature]: continue if not highest_sfx: highest_sfx = "_" + feature all_sfx.append("func" + "_" + feature) test = _umath_tests.test_dispatch() > assert_equal(test["func"], "func" + highest_sfx) E AssertionError: E Items are not equal: E ACTUAL: 'func_SSE41' E DESIRED: 'func_AVX2' all_sfx = ['func_AVX2', 'func_SSE41'] feature = 'SSE2' highest_sfx = '_AVX2' targets = ('SSE2', 'SSE41', 'AVX2', 'VSX', 'VSX2', 'VSX3', ...) test = {'all': ['func_SSE41', 'func'], 'func': 'func_SSE41', 'func_xb': 'func_SSE41', 'var': 'var_SSE41', ...} /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_cpu_dispatcher.py:31: AssertionError __________ test_npymath_complex[complex64-inf-inf-npy_cabs-absolute] ___________ fun = , npfun = , x = inf, y = inf test_dtype = @pytest.mark.parametrize( ["fun", "npfun"], [ (_multiarray_tests.npy_cabs, np.absolute), (_multiarray_tests.npy_carg, np.angle) ] ) @pytest.mark.parametrize("x", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("y", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("test_dtype", np.complexfloating.__subclasses__()) def test_npymath_complex(fun, npfun, x, y, test_dtype): # Smoketest npymath functions z = test_dtype(complex(x, y)) got = fun(z) > expected = npfun(z) E RuntimeWarning: invalid value encountered in absolute fun = got = array(inf) npfun = test_dtype = x = inf y = inf z = (inf+infj) /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_multiarray.py:8805: RuntimeWarning __________ test_npymath_complex[complex64-inf--inf-npy_cabs-absolute] __________ fun = , npfun = , x = -inf y = inf, test_dtype = @pytest.mark.parametrize( ["fun", "npfun"], [ (_multiarray_tests.npy_cabs, np.absolute), (_multiarray_tests.npy_carg, np.angle) ] ) @pytest.mark.parametrize("x", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("y", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("test_dtype", np.complexfloating.__subclasses__()) def test_npymath_complex(fun, npfun, x, y, test_dtype): # Smoketest npymath functions z = test_dtype(complex(x, y)) got = fun(z) > expected = npfun(z) E RuntimeWarning: invalid value encountered in absolute fun = got = array(inf) npfun = test_dtype = x = -inf y = inf z = (-inf+infj) /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_multiarray.py:8805: RuntimeWarning __________ test_npymath_complex[complex64--inf-inf-npy_cabs-absolute] __________ fun = , npfun = , x = inf y = -inf, test_dtype = @pytest.mark.parametrize( ["fun", "npfun"], [ (_multiarray_tests.npy_cabs, np.absolute), (_multiarray_tests.npy_carg, np.angle) ] ) @pytest.mark.parametrize("x", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("y", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("test_dtype", np.complexfloating.__subclasses__()) def test_npymath_complex(fun, npfun, x, y, test_dtype): # Smoketest npymath functions z = test_dtype(complex(x, y)) got = fun(z) > expected = npfun(z) E RuntimeWarning: invalid value encountered in absolute fun = got = array(inf) npfun = test_dtype = x = inf y = -inf z = (inf-infj) /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_multiarray.py:8805: RuntimeWarning _________ test_npymath_complex[complex64--inf--inf-npy_cabs-absolute] __________ fun = , npfun = , x = -inf y = -inf, test_dtype = @pytest.mark.parametrize( ["fun", "npfun"], [ (_multiarray_tests.npy_cabs, np.absolute), (_multiarray_tests.npy_carg, np.angle) ] ) @pytest.mark.parametrize("x", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("y", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("test_dtype", np.complexfloating.__subclasses__()) def test_npymath_complex(fun, npfun, x, y, test_dtype): # Smoketest npymath functions z = test_dtype(complex(x, y)) got = fun(z) > expected = npfun(z) E RuntimeWarning: invalid value encountered in absolute fun = got = array(inf) npfun = test_dtype = x = -inf y = -inf z = (-inf-infj) /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_multiarray.py:8805: RuntimeWarning __________ test_npymath_complex[complex128-inf-inf-npy_cabs-absolute] __________ fun = , npfun = , x = inf, y = inf test_dtype = @pytest.mark.parametrize( ["fun", "npfun"], [ (_multiarray_tests.npy_cabs, np.absolute), (_multiarray_tests.npy_carg, np.angle) ] ) @pytest.mark.parametrize("x", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("y", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("test_dtype", np.complexfloating.__subclasses__()) def test_npymath_complex(fun, npfun, x, y, test_dtype): # Smoketest npymath functions z = test_dtype(complex(x, y)) got = fun(z) > expected = npfun(z) E RuntimeWarning: invalid value encountered in absolute fun = got = array(inf) npfun = test_dtype = x = inf y = inf z = (inf+infj) /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_multiarray.py:8805: RuntimeWarning _________ test_npymath_complex[complex128-inf--inf-npy_cabs-absolute] __________ fun = , npfun = , x = -inf y = inf, test_dtype = @pytest.mark.parametrize( ["fun", "npfun"], [ (_multiarray_tests.npy_cabs, np.absolute), (_multiarray_tests.npy_carg, np.angle) ] ) @pytest.mark.parametrize("x", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("y", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("test_dtype", np.complexfloating.__subclasses__()) def test_npymath_complex(fun, npfun, x, y, test_dtype): # Smoketest npymath functions z = test_dtype(complex(x, y)) got = fun(z) > expected = npfun(z) E RuntimeWarning: invalid value encountered in absolute fun = got = array(inf) npfun = test_dtype = x = -inf y = inf z = (-inf+infj) /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_multiarray.py:8805: RuntimeWarning _________ test_npymath_complex[complex128--inf-inf-npy_cabs-absolute] __________ fun = , npfun = , x = inf y = -inf, test_dtype = @pytest.mark.parametrize( ["fun", "npfun"], [ (_multiarray_tests.npy_cabs, np.absolute), (_multiarray_tests.npy_carg, np.angle) ] ) @pytest.mark.parametrize("x", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("y", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("test_dtype", np.complexfloating.__subclasses__()) def test_npymath_complex(fun, npfun, x, y, test_dtype): # Smoketest npymath functions z = test_dtype(complex(x, y)) got = fun(z) > expected = npfun(z) E RuntimeWarning: invalid value encountered in absolute fun = got = array(inf) npfun = test_dtype = x = inf y = -inf z = (inf-infj) /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_multiarray.py:8805: RuntimeWarning _________ test_npymath_complex[complex128--inf--inf-npy_cabs-absolute] _________ fun = , npfun = , x = -inf y = -inf, test_dtype = @pytest.mark.parametrize( ["fun", "npfun"], [ (_multiarray_tests.npy_cabs, np.absolute), (_multiarray_tests.npy_carg, np.angle) ] ) @pytest.mark.parametrize("x", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("y", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("test_dtype", np.complexfloating.__subclasses__()) def test_npymath_complex(fun, npfun, x, y, test_dtype): # Smoketest npymath functions z = test_dtype(complex(x, y)) got = fun(z) > expected = npfun(z) E RuntimeWarning: invalid value encountered in absolute fun = got = array(inf) npfun = test_dtype = x = -inf y = -inf z = (-inf-infj) /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_multiarray.py:8805: RuntimeWarning __________ test_npymath_complex[complex256-inf-inf-npy_cabs-absolute] __________ fun = , npfun = , x = inf, y = inf test_dtype = @pytest.mark.parametrize( ["fun", "npfun"], [ (_multiarray_tests.npy_cabs, np.absolute), (_multiarray_tests.npy_carg, np.angle) ] ) @pytest.mark.parametrize("x", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("y", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("test_dtype", np.complexfloating.__subclasses__()) def test_npymath_complex(fun, npfun, x, y, test_dtype): # Smoketest npymath functions z = test_dtype(complex(x, y)) got = fun(z) > expected = npfun(z) E RuntimeWarning: invalid value encountered in absolute fun = got = array(inf) npfun = test_dtype = x = inf y = inf z = (inf+infj) /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_multiarray.py:8805: RuntimeWarning _________ test_npymath_complex[complex256-inf--inf-npy_cabs-absolute] __________ fun = , npfun = , x = -inf y = inf, test_dtype = @pytest.mark.parametrize( ["fun", "npfun"], [ (_multiarray_tests.npy_cabs, np.absolute), (_multiarray_tests.npy_carg, np.angle) ] ) @pytest.mark.parametrize("x", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("y", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("test_dtype", np.complexfloating.__subclasses__()) def test_npymath_complex(fun, npfun, x, y, test_dtype): # Smoketest npymath functions z = test_dtype(complex(x, y)) got = fun(z) > expected = npfun(z) E RuntimeWarning: invalid value encountered in absolute fun = got = array(inf) npfun = test_dtype = x = -inf y = inf z = (-inf+infj) /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_multiarray.py:8805: RuntimeWarning _________ test_npymath_complex[complex256--inf-inf-npy_cabs-absolute] __________ fun = , npfun = , x = inf y = -inf, test_dtype = @pytest.mark.parametrize( ["fun", "npfun"], [ (_multiarray_tests.npy_cabs, np.absolute), (_multiarray_tests.npy_carg, np.angle) ] ) @pytest.mark.parametrize("x", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("y", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("test_dtype", np.complexfloating.__subclasses__()) def test_npymath_complex(fun, npfun, x, y, test_dtype): # Smoketest npymath functions z = test_dtype(complex(x, y)) got = fun(z) > expected = npfun(z) E RuntimeWarning: invalid value encountered in absolute fun = got = array(inf) npfun = test_dtype = x = inf y = -inf z = (inf-infj) /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_multiarray.py:8805: RuntimeWarning _________ test_npymath_complex[complex256--inf--inf-npy_cabs-absolute] _________ fun = , npfun = , x = -inf y = -inf, test_dtype = @pytest.mark.parametrize( ["fun", "npfun"], [ (_multiarray_tests.npy_cabs, np.absolute), (_multiarray_tests.npy_carg, np.angle) ] ) @pytest.mark.parametrize("x", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("y", [1, np.inf, -np.inf, np.nan]) @pytest.mark.parametrize("test_dtype", np.complexfloating.__subclasses__()) def test_npymath_complex(fun, npfun, x, y, test_dtype): # Smoketest npymath functions z = test_dtype(complex(x, y)) got = fun(z) > expected = npfun(z) E RuntimeWarning: invalid value encountered in absolute fun = got = array(inf) npfun = test_dtype = x = -inf y = -inf z = (-inf-infj) /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_multiarray.py:8805: RuntimeWarning __________________________ TestBaseMath.test_blocked ___________________________ self = def test_blocked(self): # test alignments offsets for simd instructions # alignments for vz + 2 * (vs - 1) + 1 for dt, sz in [(np.float32, 11), (np.float64, 7), (np.int32, 11)]: for out, inp1, inp2, msg in _gen_alignment_data(dtype=dt, type='binary', max_size=sz): exp1 = np.ones_like(inp1) inp1[...] = np.ones_like(inp1) inp2[...] = np.zeros_like(inp2) assert_almost_equal(np.add(inp1, inp2), exp1, err_msg=msg) assert_almost_equal(np.add(inp1, 2), exp1 + 2, err_msg=msg) assert_almost_equal(np.add(1, inp2), exp1, err_msg=msg) np.add(inp1, inp2, out=out) assert_almost_equal(out, exp1, err_msg=msg) inp2[...] += np.arange(inp2.size, dtype=dt) + 1 assert_almost_equal(np.square(inp2), np.multiply(inp2, inp2), err_msg=msg) # skip true divide for ints if dt != np.int32: > assert_almost_equal(np.reciprocal(inp2), np.divide(1, inp2), err_msg=msg) E RuntimeWarning: invalid value encountered in reciprocal dt = exp1 = array([1.]) inp1 = array([1.]) inp2 = array([1.]) msg = "binary offset=(1, 0, 0), size=1, dtype=, out of place" out = array([1.]) self = sz = 7 /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_scalarmath.py:91: RuntimeWarning _____ TestUfuncGenericLoops.test_unary_PyUFunc_O_O_method_full[reciprocal] _____ self = ufunc = @pytest.mark.parametrize("ufunc", UNARY_OBJECT_UFUNCS) def test_unary_PyUFunc_O_O_method_full(self, ufunc): """Compare the result of the object loop with non-object one""" val = np.float64(np.pi/4) class MyFloat(np.float64): def __getattr__(self, attr): try: return super().__getattr__(attr) except AttributeError: return lambda: getattr(np.core.umath, attr)(val) num_arr = np.array([val], dtype=np.float64) obj_arr = np.array([MyFloat(val)], dtype="O") with np.errstate(all="raise"): try: > res_num = ufunc(num_arr) E FloatingPointError: invalid value encountered in reciprocal MyFloat = .MyFloat'> num_arr = array([0.78539816]) obj_arr = array([0.7853981633974483], dtype=object) self = ufunc = val = 0.7853981633974483 /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_ufunc.py:172: FloatingPointError During handling of the above exception, another exception occurred: self = ufunc = @pytest.mark.parametrize("ufunc", UNARY_OBJECT_UFUNCS) def test_unary_PyUFunc_O_O_method_full(self, ufunc): """Compare the result of the object loop with non-object one""" val = np.float64(np.pi/4) class MyFloat(np.float64): def __getattr__(self, attr): try: return super().__getattr__(attr) except AttributeError: return lambda: getattr(np.core.umath, attr)(val) num_arr = np.array([val], dtype=np.float64) obj_arr = np.array([MyFloat(val)], dtype="O") with np.errstate(all="raise"): try: res_num = ufunc(num_arr) except Exception as exc: with assert_raises(type(exc)): > ufunc(obj_arr) MyFloat = .MyFloat'> num_arr = array([0.78539816]) obj_arr = array([0.7853981633974483], dtype=object) self = ufunc = val = 0.7853981633974483 /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_ufunc.py:175: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /usr/local/lib/python3.8/unittest/case.py:227: in __exit__ self._raiseFailure("{} not raised".format(exc_name)) exc_name = 'FloatingPointError' exc_type = None exc_value = None self = tb = None _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ self = standardMsg = 'FloatingPointError not raised' def _raiseFailure(self, standardMsg): msg = self.test_case._formatMessage(self.msg, standardMsg) > raise self.test_case.failureException(msg) E AssertionError: FloatingPointError not raised msg = 'FloatingPointError not raised' self = standardMsg = 'FloatingPointError not raised' /usr/local/lib/python3.8/unittest/case.py:164: AssertionError __________________________ TestPower.test_power_float __________________________ self = def test_power_float(self): x = np.array([1., 2., 3.]) assert_equal(x**0, [1., 1., 1.]) assert_equal(x**1, x) assert_equal(x**2, [1., 4., 9.]) y = x.copy() y **= 2 assert_equal(y, [1., 4., 9.]) > assert_almost_equal(x**(-1), [1., 0.5, 1./3]) E RuntimeWarning: invalid value encountered in reciprocal self = x = array([1., 2., 3.]) y = array([1., 4., 9.]) /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_umath.py:716: RuntimeWarning ______________________ TestAVXUfuncs.test_avx_based_ufunc ______________________ self = def test_avx_based_ufunc(self): strides = np.array([-4,-3,-2,-1,1,2,3,4]) np.random.seed(42) for func, prop in avx_ufuncs.items(): maxulperr = prop[0] minval = prop[1] maxval = prop[2] # various array sizes to ensure masking in AVX is tested for size in range(1,32): myfunc = getattr(np, func) x_f32 = np.float32(np.random.uniform(low=minval, high=maxval, size=size)) x_f64 = np.float64(x_f32) x_f128 = np.longdouble(x_f32) y_true128 = myfunc(x_f128) if maxulperr == 0: assert_equal(myfunc(x_f32), np.float32(y_true128)) assert_equal(myfunc(x_f64), np.float64(y_true128)) else: assert_array_max_ulp(myfunc(x_f32), np.float32(y_true128), maxulp=maxulperr) > assert_array_max_ulp(myfunc(x_f64), np.float64(y_true128), maxulp=maxulperr) E RuntimeWarning: invalid value encountered in reciprocal func = 'reciprocal' jj = 4 maxulperr = 1 maxval = 100.0 minval = 1.0 myfunc = prop = [1, 1.0, 100.0] self = size = 1 strides = array([-4, -3, -2, -1, 1, 2, 3, 4]) x_f128 = array([27.94236946], dtype=float128) x_f32 = array([27.94237], dtype=float32) x_f64 = 27.94236946105957 y_true128 = array([0.03578795], dtype=float128) y_true32 = array([20.630423 , 50.93018 , 22.140877 , 42.261253 , 28.865458 , 43.80918 , 40.575657 , 13.280928 , ...0.90173674, 37.68048 , 13.034533 , 50.719593 , 63.820465 , 59.883175 , 38.939293 ], dtype=float32) y_true64 = array([20.63042259, 50.9301796 , 22.14087677, 42.26125336, 28.86545753, 43.80918121, 40.57565689, 13.28092766, ... 45.63775253, 0.90173674, 37.68048096, 13.03453255, 50.71959305, 63.82046509, 59.8831749 , 38.93929291]) /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_umath.py:1181: RuntimeWarning ________________ TestSpecialComplexAVX.test_array[complex64--1] ________________ self = stride = -1, astype = @pytest.mark.parametrize("stride", [-4,-2,-1,1,2,4]) @pytest.mark.parametrize("astype", [np.complex64, np.complex128]) def test_array(self, stride, astype): arr = np.array([complex(np.nan , np.nan), complex(np.nan , np.inf), complex(np.inf , np.nan), complex(np.inf , np.inf), complex(0. , np.inf), complex(np.inf , 0.), complex(0. , 0.), complex(0. , np.nan), complex(np.nan , 0.)], dtype=astype) abs_true = np.array([np.nan, np.inf, np.inf, np.inf, np.inf, np.inf, 0., np.nan, np.nan], dtype=arr.real.dtype) sq_true = np.array([complex(np.nan, np.nan), complex(np.nan, np.nan), complex(np.nan, np.nan), complex(np.nan, np.inf), complex(-np.inf, np.nan), complex(np.inf, np.nan), complex(0., 0.), complex(np.nan, np.nan), complex(np.nan, np.nan)], dtype=astype) > assert_equal(np.abs(arr[::stride]), abs_true[::stride]) E RuntimeWarning: invalid value encountered in absolute abs_true = array([nan, inf, inf, inf, inf, inf, 0., nan, nan], dtype=float32) arr = array([nan+nanj, nan+infj, inf+nanj, inf+infj, 0.+infj, inf +0.j, 0. +0.j, 0.+nanj, nan +0.j], dtype=complex64) astype = self = sq_true = array([ nan+nanj, nan+nanj, nan+nanj, nan+infj, -inf+nanj, inf+nanj, 0. +0.j, nan+nanj, nan+nanj], dtype=complex64) stride = -1 /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_umath_complex.py:581: RuntimeWarning ________________ TestSpecialComplexAVX.test_array[complex64-1] _________________ self = stride = 1, astype = @pytest.mark.parametrize("stride", [-4,-2,-1,1,2,4]) @pytest.mark.parametrize("astype", [np.complex64, np.complex128]) def test_array(self, stride, astype): arr = np.array([complex(np.nan , np.nan), complex(np.nan , np.inf), complex(np.inf , np.nan), complex(np.inf , np.inf), complex(0. , np.inf), complex(np.inf , 0.), complex(0. , 0.), complex(0. , np.nan), complex(np.nan , 0.)], dtype=astype) abs_true = np.array([np.nan, np.inf, np.inf, np.inf, np.inf, np.inf, 0., np.nan, np.nan], dtype=arr.real.dtype) sq_true = np.array([complex(np.nan, np.nan), complex(np.nan, np.nan), complex(np.nan, np.nan), complex(np.nan, np.inf), complex(-np.inf, np.nan), complex(np.inf, np.nan), complex(0., 0.), complex(np.nan, np.nan), complex(np.nan, np.nan)], dtype=astype) > assert_equal(np.abs(arr[::stride]), abs_true[::stride]) E RuntimeWarning: invalid value encountered in absolute abs_true = array([nan, inf, inf, inf, inf, inf, 0., nan, nan], dtype=float32) arr = array([nan+nanj, nan+infj, inf+nanj, inf+infj, 0.+infj, inf +0.j, 0. +0.j, 0.+nanj, nan +0.j], dtype=complex64) astype = self = sq_true = array([ nan+nanj, nan+nanj, nan+nanj, nan+infj, -inf+nanj, inf+nanj, 0. +0.j, nan+nanj, nan+nanj], dtype=complex64) stride = 1 /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_umath_complex.py:581: RuntimeWarning _______________ TestSpecialComplexAVX.test_array[complex128--1] ________________ self = stride = -1, astype = @pytest.mark.parametrize("stride", [-4,-2,-1,1,2,4]) @pytest.mark.parametrize("astype", [np.complex64, np.complex128]) def test_array(self, stride, astype): arr = np.array([complex(np.nan , np.nan), complex(np.nan , np.inf), complex(np.inf , np.nan), complex(np.inf , np.inf), complex(0. , np.inf), complex(np.inf , 0.), complex(0. , 0.), complex(0. , np.nan), complex(np.nan , 0.)], dtype=astype) abs_true = np.array([np.nan, np.inf, np.inf, np.inf, np.inf, np.inf, 0., np.nan, np.nan], dtype=arr.real.dtype) sq_true = np.array([complex(np.nan, np.nan), complex(np.nan, np.nan), complex(np.nan, np.nan), complex(np.nan, np.inf), complex(-np.inf, np.nan), complex(np.inf, np.nan), complex(0., 0.), complex(np.nan, np.nan), complex(np.nan, np.nan)], dtype=astype) > assert_equal(np.abs(arr[::stride]), abs_true[::stride]) E RuntimeWarning: invalid value encountered in absolute abs_true = array([nan, inf, inf, inf, inf, inf, 0., nan, nan]) arr = array([nan+nanj, nan+infj, inf+nanj, inf+infj, 0.+infj, inf +0.j, 0. +0.j, 0.+nanj, nan +0.j]) astype = self = sq_true = array([ nan+nanj, nan+nanj, nan+nanj, nan+infj, -inf+nanj, inf+nanj, 0. +0.j, nan+nanj, nan+nanj]) stride = -1 /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_umath_complex.py:581: RuntimeWarning ________________ TestSpecialComplexAVX.test_array[complex128-1] ________________ self = stride = 1, astype = @pytest.mark.parametrize("stride", [-4,-2,-1,1,2,4]) @pytest.mark.parametrize("astype", [np.complex64, np.complex128]) def test_array(self, stride, astype): arr = np.array([complex(np.nan , np.nan), complex(np.nan , np.inf), complex(np.inf , np.nan), complex(np.inf , np.inf), complex(0. , np.inf), complex(np.inf , 0.), complex(0. , 0.), complex(0. , np.nan), complex(np.nan , 0.)], dtype=astype) abs_true = np.array([np.nan, np.inf, np.inf, np.inf, np.inf, np.inf, 0., np.nan, np.nan], dtype=arr.real.dtype) sq_true = np.array([complex(np.nan, np.nan), complex(np.nan, np.nan), complex(np.nan, np.nan), complex(np.nan, np.inf), complex(-np.inf, np.nan), complex(np.inf, np.nan), complex(0., 0.), complex(np.nan, np.nan), complex(np.nan, np.nan)], dtype=astype) > assert_equal(np.abs(arr[::stride]), abs_true[::stride]) E RuntimeWarning: invalid value encountered in absolute abs_true = array([nan, inf, inf, inf, inf, inf, 0., nan, nan]) arr = array([nan+nanj, nan+infj, inf+nanj, inf+infj, 0.+infj, inf +0.j, 0. +0.j, 0.+nanj, nan +0.j]) astype = self = sq_true = array([ nan+nanj, nan+nanj, nan+nanj, nan+infj, -inf+nanj, inf+nanj, 0. +0.j, nan+nanj, nan+nanj]) stride = 1 /usr/local/lib/python3.8/site-packages/numpy/core/tests/test_umath_complex.py:581: RuntimeWarning ____________________ TestNormDouble.test_vector_return_type ____________________ self = def test_vector_return_type(self): a = np.array([1, 0, 1]) exact_types = np.typecodes['AllInteger'] inexact_types = np.typecodes['AllFloat'] all_types = exact_types + inexact_types for each_inexact_types in all_types: at = a.astype(each_inexact_types) an = norm(at, -np.inf) assert_(issubclass(an.dtype.type, np.floating)) assert_almost_equal(an, 0.0) with suppress_warnings() as sup: sup.filter(RuntimeWarning, "divide by zero encountered") > an = norm(at, -1) a = array([1, 0, 1]) all_types = 'bBhHiIlLqQpPefdgFDG' an = 0.0 at = array([1, 0, 1], dtype=int8) each_inexact_types = 'b' exact_types = 'bBhHiIlLqQpP' inexact_types = 'efdgFDG' self = sup = /usr/local/lib/python3.8/site-packages/numpy/linalg/tests/test_linalg.py:1252: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ <__array_function__ internals>:5: in norm ??? args = (array([1, 0, 1], dtype=int8), -1) kwargs = {} relevant_args = (array([1, 0, 1], dtype=int8),) _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ x = array([1., 0., 1.]), ord = -1, axis = (0,), keepdims = False @array_function_dispatch(_norm_dispatcher) def norm(x, ord=None, axis=None, keepdims=False): """ Matrix or vector norm. This function is able to return one of eight different matrix norms, or one of an infinite number of vector norms (described below), depending on the value of the ``ord`` parameter. Parameters ---------- x : array_like Input array. If `axis` is None, `x` must be 1-D or 2-D, unless `ord` is None. If both `axis` and `ord` are None, the 2-norm of ``x.ravel`` will be returned. ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional Order of the norm (see table under ``Notes``). inf means numpy's `inf` object. The default is None. axis : {None, int, 2-tuple of ints}, optional. If `axis` is an integer, it specifies the axis of `x` along which to compute the vector norms. If `axis` is a 2-tuple, it specifies the axes that hold 2-D matrices, and the matrix norms of these matrices are computed. If `axis` is None then either a vector norm (when `x` is 1-D) or a matrix norm (when `x` is 2-D) is returned. The default is None. .. versionadded:: 1.8.0 keepdims : bool, optional If this is set to True, the axes which are normed over are left in the result as dimensions with size one. With this option the result will broadcast correctly against the original `x`. .. versionadded:: 1.10.0 Returns ------- n : float or ndarray Norm of the matrix or vector(s). See Also -------- scipy.linalg.norm : Similar function in SciPy. Notes ----- For values of ``ord < 1``, the result is, strictly speaking, not a mathematical 'norm', but it may still be useful for various numerical purposes. The following norms can be calculated: ===== ============================ ========================== ord norm for matrices norm for vectors ===== ============================ ========================== None Frobenius norm 2-norm 'fro' Frobenius norm -- 'nuc' nuclear norm -- inf max(sum(abs(x), axis=1)) max(abs(x)) -inf min(sum(abs(x), axis=1)) min(abs(x)) 0 -- sum(x != 0) 1 max(sum(abs(x), axis=0)) as below -1 min(sum(abs(x), axis=0)) as below 2 2-norm (largest sing. value) as below -2 smallest singular value as below other -- sum(abs(x)**ord)**(1./ord) ===== ============================ ========================== The Frobenius norm is given by [1]_: :math:`||A||_F = [\\sum_{i,j} abs(a_{i,j})^2]^{1/2}` The nuclear norm is the sum of the singular values. Both the Frobenius and nuclear norm orders are only defined for matrices and raise a ValueError when ``x.ndim != 2``. References ---------- .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*, Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15 Examples -------- >>> from numpy import linalg as LA >>> a = np.arange(9) - 4 >>> a array([-4, -3, -2, ..., 2, 3, 4]) >>> b = a.reshape((3, 3)) >>> b array([[-4, -3, -2], [-1, 0, 1], [ 2, 3, 4]]) >>> LA.norm(a) 7.745966692414834 >>> LA.norm(b) 7.745966692414834 >>> LA.norm(b, 'fro') 7.745966692414834 >>> LA.norm(a, np.inf) 4.0 >>> LA.norm(b, np.inf) 9.0 >>> LA.norm(a, -np.inf) 0.0 >>> LA.norm(b, -np.inf) 2.0 >>> LA.norm(a, 1) 20.0 >>> LA.norm(b, 1) 7.0 >>> LA.norm(a, -1) -4.6566128774142013e-010 >>> LA.norm(b, -1) 6.0 >>> LA.norm(a, 2) 7.745966692414834 >>> LA.norm(b, 2) 7.3484692283495345 >>> LA.norm(a, -2) 0.0 >>> LA.norm(b, -2) 1.8570331885190563e-016 # may vary >>> LA.norm(a, 3) 5.8480354764257312 # may vary >>> LA.norm(a, -3) 0.0 Using the `axis` argument to compute vector norms: >>> c = np.array([[ 1, 2, 3], ... [-1, 1, 4]]) >>> LA.norm(c, axis=0) array([ 1.41421356, 2.23606798, 5. ]) >>> LA.norm(c, axis=1) array([ 3.74165739, 4.24264069]) >>> LA.norm(c, ord=1, axis=1) array([ 6., 6.]) Using the `axis` argument to compute matrix norms: >>> m = np.arange(8).reshape(2,2,2) >>> LA.norm(m, axis=(1,2)) array([ 3.74165739, 11.22497216]) >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :]) (3.7416573867739413, 11.224972160321824) """ x = asarray(x) if not issubclass(x.dtype.type, (inexact, object_)): x = x.astype(float) # Immediately handle some default, simple, fast, and common cases. if axis is None: ndim = x.ndim if ((ord is None) or (ord in ('f', 'fro') and ndim == 2) or (ord == 2 and ndim == 1)): x = x.ravel(order='K') if isComplexType(x.dtype.type): sqnorm = dot(x.real, x.real) + dot(x.imag, x.imag) else: sqnorm = dot(x, x) ret = sqrt(sqnorm) if keepdims: ret = ret.reshape(ndim*[1]) return ret # Normalize the `axis` argument to a tuple. nd = x.ndim if axis is None: axis = tuple(range(nd)) elif not isinstance(axis, tuple): try: axis = int(axis) except Exception as e: raise TypeError("'axis' must be None, an integer or a tuple of integers") from e axis = (axis,) if len(axis) == 1: if ord == Inf: return abs(x).max(axis=axis, keepdims=keepdims) elif ord == -Inf: return abs(x).min(axis=axis, keepdims=keepdims) elif ord == 0: # Zero norm return (x != 0).astype(x.real.dtype).sum(axis=axis, keepdims=keepdims) elif ord == 1: # special case for speedup return add.reduce(abs(x), axis=axis, keepdims=keepdims) elif ord is None or ord == 2: # special case for speedup s = (x.conj() * x).real return sqrt(add.reduce(s, axis=axis, keepdims=keepdims)) # None of the str-type keywords for ord ('fro', 'nuc') # are valid for vectors elif isinstance(ord, str): raise ValueError(f"Invalid norm order '{ord}' for vectors") else: absx = abs(x) > absx **= ord E RuntimeWarning: invalid value encountered in reciprocal absx = array([ 1., inf, 1.]) axis = (0,) keepdims = False nd = 1 ndim = 1 ord = -1 x = array([1., 0., 1.]) /usr/local/lib/python3.8/site-packages/numpy/linalg/linalg.py:2568: RuntimeWarning ___________________________ TestNormDouble.test_axis ___________________________ self = def test_axis(self): # Vector norms. # Compare the use of `axis` with computing the norm of each row # or column separately. A = array([[1, 2, 3], [4, 5, 6]], dtype=self.dt) for order in [None, -1, 0, 1, 2, 3, np.Inf, -np.Inf]: expected0 = [norm(A[:, k], ord=order) for k in range(A.shape[1])] > assert_almost_equal(norm(A, ord=order, axis=0), expected0) A = array([[1., 2., 3.], [4., 5., 6.]]) expected0 = [0.8, 1.4285714285714286, 2.0] expected1 = [3.7416573867739413, 8.774964387392123] order = -1 self = /usr/local/lib/python3.8/site-packages/numpy/linalg/tests/test_linalg.py:1313: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ <__array_function__ internals>:5: in norm ??? args = (array([[1., 2., 3.], [4., 5., 6.]]),) kwargs = {'axis': 0, 'ord': -1} relevant_args = (array([[1., 2., 3.], [4., 5., 6.]]),) _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ x = array([[1., 2., 3.], [4., 5., 6.]]), ord = -1, axis = (0,) keepdims = False @array_function_dispatch(_norm_dispatcher) def norm(x, ord=None, axis=None, keepdims=False): """ Matrix or vector norm. This function is able to return one of eight different matrix norms, or one of an infinite number of vector norms (described below), depending on the value of the ``ord`` parameter. Parameters ---------- x : array_like Input array. If `axis` is None, `x` must be 1-D or 2-D, unless `ord` is None. If both `axis` and `ord` are None, the 2-norm of ``x.ravel`` will be returned. ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional Order of the norm (see table under ``Notes``). inf means numpy's `inf` object. The default is None. axis : {None, int, 2-tuple of ints}, optional. If `axis` is an integer, it specifies the axis of `x` along which to compute the vector norms. If `axis` is a 2-tuple, it specifies the axes that hold 2-D matrices, and the matrix norms of these matrices are computed. If `axis` is None then either a vector norm (when `x` is 1-D) or a matrix norm (when `x` is 2-D) is returned. The default is None. .. versionadded:: 1.8.0 keepdims : bool, optional If this is set to True, the axes which are normed over are left in the result as dimensions with size one. With this option the result will broadcast correctly against the original `x`. .. versionadded:: 1.10.0 Returns ------- n : float or ndarray Norm of the matrix or vector(s). See Also -------- scipy.linalg.norm : Similar function in SciPy. Notes ----- For values of ``ord < 1``, the result is, strictly speaking, not a mathematical 'norm', but it may still be useful for various numerical purposes. The following norms can be calculated: ===== ============================ ========================== ord norm for matrices norm for vectors ===== ============================ ========================== None Frobenius norm 2-norm 'fro' Frobenius norm -- 'nuc' nuclear norm -- inf max(sum(abs(x), axis=1)) max(abs(x)) -inf min(sum(abs(x), axis=1)) min(abs(x)) 0 -- sum(x != 0) 1 max(sum(abs(x), axis=0)) as below -1 min(sum(abs(x), axis=0)) as below 2 2-norm (largest sing. value) as below -2 smallest singular value as below other -- sum(abs(x)**ord)**(1./ord) ===== ============================ ========================== The Frobenius norm is given by [1]_: :math:`||A||_F = [\\sum_{i,j} abs(a_{i,j})^2]^{1/2}` The nuclear norm is the sum of the singular values. Both the Frobenius and nuclear norm orders are only defined for matrices and raise a ValueError when ``x.ndim != 2``. References ---------- .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*, Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15 Examples -------- >>> from numpy import linalg as LA >>> a = np.arange(9) - 4 >>> a array([-4, -3, -2, ..., 2, 3, 4]) >>> b = a.reshape((3, 3)) >>> b array([[-4, -3, -2], [-1, 0, 1], [ 2, 3, 4]]) >>> LA.norm(a) 7.745966692414834 >>> LA.norm(b) 7.745966692414834 >>> LA.norm(b, 'fro') 7.745966692414834 >>> LA.norm(a, np.inf) 4.0 >>> LA.norm(b, np.inf) 9.0 >>> LA.norm(a, -np.inf) 0.0 >>> LA.norm(b, -np.inf) 2.0 >>> LA.norm(a, 1) 20.0 >>> LA.norm(b, 1) 7.0 >>> LA.norm(a, -1) -4.6566128774142013e-010 >>> LA.norm(b, -1) 6.0 >>> LA.norm(a, 2) 7.745966692414834 >>> LA.norm(b, 2) 7.3484692283495345 >>> LA.norm(a, -2) 0.0 >>> LA.norm(b, -2) 1.8570331885190563e-016 # may vary >>> LA.norm(a, 3) 5.8480354764257312 # may vary >>> LA.norm(a, -3) 0.0 Using the `axis` argument to compute vector norms: >>> c = np.array([[ 1, 2, 3], ... [-1, 1, 4]]) >>> LA.norm(c, axis=0) array([ 1.41421356, 2.23606798, 5. ]) >>> LA.norm(c, axis=1) array([ 3.74165739, 4.24264069]) >>> LA.norm(c, ord=1, axis=1) array([ 6., 6.]) Using the `axis` argument to compute matrix norms: >>> m = np.arange(8).reshape(2,2,2) >>> LA.norm(m, axis=(1,2)) array([ 3.74165739, 11.22497216]) >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :]) (3.7416573867739413, 11.224972160321824) """ x = asarray(x) if not issubclass(x.dtype.type, (inexact, object_)): x = x.astype(float) # Immediately handle some default, simple, fast, and common cases. if axis is None: ndim = x.ndim if ((ord is None) or (ord in ('f', 'fro') and ndim == 2) or (ord == 2 and ndim == 1)): x = x.ravel(order='K') if isComplexType(x.dtype.type): sqnorm = dot(x.real, x.real) + dot(x.imag, x.imag) else: sqnorm = dot(x, x) ret = sqrt(sqnorm) if keepdims: ret = ret.reshape(ndim*[1]) return ret # Normalize the `axis` argument to a tuple. nd = x.ndim if axis is None: axis = tuple(range(nd)) elif not isinstance(axis, tuple): try: axis = int(axis) except Exception as e: raise TypeError("'axis' must be None, an integer or a tuple of integers") from e axis = (axis,) if len(axis) == 1: if ord == Inf: return abs(x).max(axis=axis, keepdims=keepdims) elif ord == -Inf: return abs(x).min(axis=axis, keepdims=keepdims) elif ord == 0: # Zero norm return (x != 0).astype(x.real.dtype).sum(axis=axis, keepdims=keepdims) elif ord == 1: # special case for speedup return add.reduce(abs(x), axis=axis, keepdims=keepdims) elif ord is None or ord == 2: # special case for speedup s = (x.conj() * x).real return sqrt(add.reduce(s, axis=axis, keepdims=keepdims)) # None of the str-type keywords for ord ('fro', 'nuc') # are valid for vectors elif isinstance(ord, str): raise ValueError(f"Invalid norm order '{ord}' for vectors") else: absx = abs(x) absx **= ord ret = add.reduce(absx, axis=axis, keepdims=keepdims) > ret **= (1 / ord) E RuntimeWarning: invalid value encountered in reciprocal absx = array([[1. , 0.5 , 0.33333333], [0.25 , 0.2 , 0.16666667]]) axis = (0,) keepdims = False nd = 2 ord = -1 ret = array([0.8 , 1.42857143, 2. ]) x = array([[1., 2., 3.], [4., 5., 6.]]) /usr/local/lib/python3.8/site-packages/numpy/linalg/linalg.py:2570: RuntimeWarning ____________________ TestNormSingle.test_vector_return_type ____________________ self = def test_vector_return_type(self): a = np.array([1, 0, 1]) exact_types = np.typecodes['AllInteger'] inexact_types = np.typecodes['AllFloat'] all_types = exact_types + inexact_types for each_inexact_types in all_types: at = a.astype(each_inexact_types) an = norm(at, -np.inf) assert_(issubclass(an.dtype.type, np.floating)) assert_almost_equal(an, 0.0) with suppress_warnings() as sup: sup.filter(RuntimeWarning, "divide by zero encountered") > an = norm(at, -1) a = array([1, 0, 1]) all_types = 'bBhHiIlLqQpPefdgFDG' an = 0.0 at = array([1, 0, 1], dtype=int8) each_inexact_types = 'b' exact_types = 'bBhHiIlLqQpP' inexact_types = 'efdgFDG' self = sup = /usr/local/lib/python3.8/site-packages/numpy/linalg/tests/test_linalg.py:1252: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ <__array_function__ internals>:5: in norm ??? args = (array([1, 0, 1], dtype=int8), -1) kwargs = {} relevant_args = (array([1, 0, 1], dtype=int8),) _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ x = array([1., 0., 1.]), ord = -1, axis = (0,), keepdims = False @array_function_dispatch(_norm_dispatcher) def norm(x, ord=None, axis=None, keepdims=False): """ Matrix or vector norm. This function is able to return one of eight different matrix norms, or one of an infinite number of vector norms (described below), depending on the value of the ``ord`` parameter. Parameters ---------- x : array_like Input array. If `axis` is None, `x` must be 1-D or 2-D, unless `ord` is None. If both `axis` and `ord` are None, the 2-norm of ``x.ravel`` will be returned. ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional Order of the norm (see table under ``Notes``). inf means numpy's `inf` object. The default is None. axis : {None, int, 2-tuple of ints}, optional. If `axis` is an integer, it specifies the axis of `x` along which to compute the vector norms. If `axis` is a 2-tuple, it specifies the axes that hold 2-D matrices, and the matrix norms of these matrices are computed. If `axis` is None then either a vector norm (when `x` is 1-D) or a matrix norm (when `x` is 2-D) is returned. The default is None. .. versionadded:: 1.8.0 keepdims : bool, optional If this is set to True, the axes which are normed over are left in the result as dimensions with size one. With this option the result will broadcast correctly against the original `x`. .. versionadded:: 1.10.0 Returns ------- n : float or ndarray Norm of the matrix or vector(s). See Also -------- scipy.linalg.norm : Similar function in SciPy. Notes ----- For values of ``ord < 1``, the result is, strictly speaking, not a mathematical 'norm', but it may still be useful for various numerical purposes. The following norms can be calculated: ===== ============================ ========================== ord norm for matrices norm for vectors ===== ============================ ========================== None Frobenius norm 2-norm 'fro' Frobenius norm -- 'nuc' nuclear norm -- inf max(sum(abs(x), axis=1)) max(abs(x)) -inf min(sum(abs(x), axis=1)) min(abs(x)) 0 -- sum(x != 0) 1 max(sum(abs(x), axis=0)) as below -1 min(sum(abs(x), axis=0)) as below 2 2-norm (largest sing. value) as below -2 smallest singular value as below other -- sum(abs(x)**ord)**(1./ord) ===== ============================ ========================== The Frobenius norm is given by [1]_: :math:`||A||_F = [\\sum_{i,j} abs(a_{i,j})^2]^{1/2}` The nuclear norm is the sum of the singular values. Both the Frobenius and nuclear norm orders are only defined for matrices and raise a ValueError when ``x.ndim != 2``. References ---------- .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*, Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15 Examples -------- >>> from numpy import linalg as LA >>> a = np.arange(9) - 4 >>> a array([-4, -3, -2, ..., 2, 3, 4]) >>> b = a.reshape((3, 3)) >>> b array([[-4, -3, -2], [-1, 0, 1], [ 2, 3, 4]]) >>> LA.norm(a) 7.745966692414834 >>> LA.norm(b) 7.745966692414834 >>> LA.norm(b, 'fro') 7.745966692414834 >>> LA.norm(a, np.inf) 4.0 >>> LA.norm(b, np.inf) 9.0 >>> LA.norm(a, -np.inf) 0.0 >>> LA.norm(b, -np.inf) 2.0 >>> LA.norm(a, 1) 20.0 >>> LA.norm(b, 1) 7.0 >>> LA.norm(a, -1) -4.6566128774142013e-010 >>> LA.norm(b, -1) 6.0 >>> LA.norm(a, 2) 7.745966692414834 >>> LA.norm(b, 2) 7.3484692283495345 >>> LA.norm(a, -2) 0.0 >>> LA.norm(b, -2) 1.8570331885190563e-016 # may vary >>> LA.norm(a, 3) 5.8480354764257312 # may vary >>> LA.norm(a, -3) 0.0 Using the `axis` argument to compute vector norms: >>> c = np.array([[ 1, 2, 3], ... [-1, 1, 4]]) >>> LA.norm(c, axis=0) array([ 1.41421356, 2.23606798, 5. ]) >>> LA.norm(c, axis=1) array([ 3.74165739, 4.24264069]) >>> LA.norm(c, ord=1, axis=1) array([ 6., 6.]) Using the `axis` argument to compute matrix norms: >>> m = np.arange(8).reshape(2,2,2) >>> LA.norm(m, axis=(1,2)) array([ 3.74165739, 11.22497216]) >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :]) (3.7416573867739413, 11.224972160321824) """ x = asarray(x) if not issubclass(x.dtype.type, (inexact, object_)): x = x.astype(float) # Immediately handle some default, simple, fast, and common cases. if axis is None: ndim = x.ndim if ((ord is None) or (ord in ('f', 'fro') and ndim == 2) or (ord == 2 and ndim == 1)): x = x.ravel(order='K') if isComplexType(x.dtype.type): sqnorm = dot(x.real, x.real) + dot(x.imag, x.imag) else: sqnorm = dot(x, x) ret = sqrt(sqnorm) if keepdims: ret = ret.reshape(ndim*[1]) return ret # Normalize the `axis` argument to a tuple. nd = x.ndim if axis is None: axis = tuple(range(nd)) elif not isinstance(axis, tuple): try: axis = int(axis) except Exception as e: raise TypeError("'axis' must be None, an integer or a tuple of integers") from e axis = (axis,) if len(axis) == 1: if ord == Inf: return abs(x).max(axis=axis, keepdims=keepdims) elif ord == -Inf: return abs(x).min(axis=axis, keepdims=keepdims) elif ord == 0: # Zero norm return (x != 0).astype(x.real.dtype).sum(axis=axis, keepdims=keepdims) elif ord == 1: # special case for speedup return add.reduce(abs(x), axis=axis, keepdims=keepdims) elif ord is None or ord == 2: # special case for speedup s = (x.conj() * x).real return sqrt(add.reduce(s, axis=axis, keepdims=keepdims)) # None of the str-type keywords for ord ('fro', 'nuc') # are valid for vectors elif isinstance(ord, str): raise ValueError(f"Invalid norm order '{ord}' for vectors") else: absx = abs(x) > absx **= ord E RuntimeWarning: invalid value encountered in reciprocal absx = array([ 1., inf, 1.]) axis = (0,) keepdims = False nd = 1 ndim = 1 ord = -1 x = array([1., 0., 1.]) /usr/local/lib/python3.8/site-packages/numpy/linalg/linalg.py:2568: RuntimeWarning ____________________ TestNormInt64.test_vector_return_type _____________________ self = def test_vector_return_type(self): a = np.array([1, 0, 1]) exact_types = np.typecodes['AllInteger'] inexact_types = np.typecodes['AllFloat'] all_types = exact_types + inexact_types for each_inexact_types in all_types: at = a.astype(each_inexact_types) an = norm(at, -np.inf) assert_(issubclass(an.dtype.type, np.floating)) assert_almost_equal(an, 0.0) with suppress_warnings() as sup: sup.filter(RuntimeWarning, "divide by zero encountered") > an = norm(at, -1) a = array([1, 0, 1]) all_types = 'bBhHiIlLqQpPefdgFDG' an = 0.0 at = array([1, 0, 1], dtype=int8) each_inexact_types = 'b' exact_types = 'bBhHiIlLqQpP' inexact_types = 'efdgFDG' self = sup = /usr/local/lib/python3.8/site-packages/numpy/linalg/tests/test_linalg.py:1252: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ <__array_function__ internals>:5: in norm ??? args = (array([1, 0, 1], dtype=int8), -1) kwargs = {} relevant_args = (array([1, 0, 1], dtype=int8),) _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ x = array([1., 0., 1.]), ord = -1, axis = (0,), keepdims = False @array_function_dispatch(_norm_dispatcher) def norm(x, ord=None, axis=None, keepdims=False): """ Matrix or vector norm. This function is able to return one of eight different matrix norms, or one of an infinite number of vector norms (described below), depending on the value of the ``ord`` parameter. Parameters ---------- x : array_like Input array. If `axis` is None, `x` must be 1-D or 2-D, unless `ord` is None. If both `axis` and `ord` are None, the 2-norm of ``x.ravel`` will be returned. ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional Order of the norm (see table under ``Notes``). inf means numpy's `inf` object. The default is None. axis : {None, int, 2-tuple of ints}, optional. If `axis` is an integer, it specifies the axis of `x` along which to compute the vector norms. If `axis` is a 2-tuple, it specifies the axes that hold 2-D matrices, and the matrix norms of these matrices are computed. If `axis` is None then either a vector norm (when `x` is 1-D) or a matrix norm (when `x` is 2-D) is returned. The default is None. .. versionadded:: 1.8.0 keepdims : bool, optional If this is set to True, the axes which are normed over are left in the result as dimensions with size one. With this option the result will broadcast correctly against the original `x`. .. versionadded:: 1.10.0 Returns ------- n : float or ndarray Norm of the matrix or vector(s). See Also -------- scipy.linalg.norm : Similar function in SciPy. Notes ----- For values of ``ord < 1``, the result is, strictly speaking, not a mathematical 'norm', but it may still be useful for various numerical purposes. The following norms can be calculated: ===== ============================ ========================== ord norm for matrices norm for vectors ===== ============================ ========================== None Frobenius norm 2-norm 'fro' Frobenius norm -- 'nuc' nuclear norm -- inf max(sum(abs(x), axis=1)) max(abs(x)) -inf min(sum(abs(x), axis=1)) min(abs(x)) 0 -- sum(x != 0) 1 max(sum(abs(x), axis=0)) as below -1 min(sum(abs(x), axis=0)) as below 2 2-norm (largest sing. value) as below -2 smallest singular value as below other -- sum(abs(x)**ord)**(1./ord) ===== ============================ ========================== The Frobenius norm is given by [1]_: :math:`||A||_F = [\\sum_{i,j} abs(a_{i,j})^2]^{1/2}` The nuclear norm is the sum of the singular values. Both the Frobenius and nuclear norm orders are only defined for matrices and raise a ValueError when ``x.ndim != 2``. References ---------- .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*, Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15 Examples -------- >>> from numpy import linalg as LA >>> a = np.arange(9) - 4 >>> a array([-4, -3, -2, ..., 2, 3, 4]) >>> b = a.reshape((3, 3)) >>> b array([[-4, -3, -2], [-1, 0, 1], [ 2, 3, 4]]) >>> LA.norm(a) 7.745966692414834 >>> LA.norm(b) 7.745966692414834 >>> LA.norm(b, 'fro') 7.745966692414834 >>> LA.norm(a, np.inf) 4.0 >>> LA.norm(b, np.inf) 9.0 >>> LA.norm(a, -np.inf) 0.0 >>> LA.norm(b, -np.inf) 2.0 >>> LA.norm(a, 1) 20.0 >>> LA.norm(b, 1) 7.0 >>> LA.norm(a, -1) -4.6566128774142013e-010 >>> LA.norm(b, -1) 6.0 >>> LA.norm(a, 2) 7.745966692414834 >>> LA.norm(b, 2) 7.3484692283495345 >>> LA.norm(a, -2) 0.0 >>> LA.norm(b, -2) 1.8570331885190563e-016 # may vary >>> LA.norm(a, 3) 5.8480354764257312 # may vary >>> LA.norm(a, -3) 0.0 Using the `axis` argument to compute vector norms: >>> c = np.array([[ 1, 2, 3], ... [-1, 1, 4]]) >>> LA.norm(c, axis=0) array([ 1.41421356, 2.23606798, 5. ]) >>> LA.norm(c, axis=1) array([ 3.74165739, 4.24264069]) >>> LA.norm(c, ord=1, axis=1) array([ 6., 6.]) Using the `axis` argument to compute matrix norms: >>> m = np.arange(8).reshape(2,2,2) >>> LA.norm(m, axis=(1,2)) array([ 3.74165739, 11.22497216]) >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :]) (3.7416573867739413, 11.224972160321824) """ x = asarray(x) if not issubclass(x.dtype.type, (inexact, object_)): x = x.astype(float) # Immediately handle some default, simple, fast, and common cases. if axis is None: ndim = x.ndim if ((ord is None) or (ord in ('f', 'fro') and ndim == 2) or (ord == 2 and ndim == 1)): x = x.ravel(order='K') if isComplexType(x.dtype.type): sqnorm = dot(x.real, x.real) + dot(x.imag, x.imag) else: sqnorm = dot(x, x) ret = sqrt(sqnorm) if keepdims: ret = ret.reshape(ndim*[1]) return ret # Normalize the `axis` argument to a tuple. nd = x.ndim if axis is None: axis = tuple(range(nd)) elif not isinstance(axis, tuple): try: axis = int(axis) except Exception as e: raise TypeError("'axis' must be None, an integer or a tuple of integers") from e axis = (axis,) if len(axis) == 1: if ord == Inf: return abs(x).max(axis=axis, keepdims=keepdims) elif ord == -Inf: return abs(x).min(axis=axis, keepdims=keepdims) elif ord == 0: # Zero norm return (x != 0).astype(x.real.dtype).sum(axis=axis, keepdims=keepdims) elif ord == 1: # special case for speedup return add.reduce(abs(x), axis=axis, keepdims=keepdims) elif ord is None or ord == 2: # special case for speedup s = (x.conj() * x).real return sqrt(add.reduce(s, axis=axis, keepdims=keepdims)) # None of the str-type keywords for ord ('fro', 'nuc') # are valid for vectors elif isinstance(ord, str): raise ValueError(f"Invalid norm order '{ord}' for vectors") else: absx = abs(x) > absx **= ord E RuntimeWarning: invalid value encountered in reciprocal absx = array([ 1., inf, 1.]) axis = (0,) keepdims = False nd = 1 ndim = 1 ord = -1 x = array([1., 0., 1.]) /usr/local/lib/python3.8/site-packages/numpy/linalg/linalg.py:2568: RuntimeWarning ___________________________ TestNormInt64.test_axis ____________________________ self = def test_axis(self): # Vector norms. # Compare the use of `axis` with computing the norm of each row # or column separately. A = array([[1, 2, 3], [4, 5, 6]], dtype=self.dt) for order in [None, -1, 0, 1, 2, 3, np.Inf, -np.Inf]: expected0 = [norm(A[:, k], ord=order) for k in range(A.shape[1])] > assert_almost_equal(norm(A, ord=order, axis=0), expected0) A = array([[1, 2, 3], [4, 5, 6]]) expected0 = [0.8, 1.4285714285714286, 2.0] expected1 = [3.7416573867739413, 8.774964387392123] order = -1 self = /usr/local/lib/python3.8/site-packages/numpy/linalg/tests/test_linalg.py:1313: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ <__array_function__ internals>:5: in norm ??? args = (array([[1, 2, 3], [4, 5, 6]]),) kwargs = {'axis': 0, 'ord': -1} relevant_args = (array([[1, 2, 3], [4, 5, 6]]),) _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ x = array([[1., 2., 3.], [4., 5., 6.]]), ord = -1, axis = (0,) keepdims = False @array_function_dispatch(_norm_dispatcher) def norm(x, ord=None, axis=None, keepdims=False): """ Matrix or vector norm. This function is able to return one of eight different matrix norms, or one of an infinite number of vector norms (described below), depending on the value of the ``ord`` parameter. Parameters ---------- x : array_like Input array. If `axis` is None, `x` must be 1-D or 2-D, unless `ord` is None. If both `axis` and `ord` are None, the 2-norm of ``x.ravel`` will be returned. ord : {non-zero int, inf, -inf, 'fro', 'nuc'}, optional Order of the norm (see table under ``Notes``). inf means numpy's `inf` object. The default is None. axis : {None, int, 2-tuple of ints}, optional. If `axis` is an integer, it specifies the axis of `x` along which to compute the vector norms. If `axis` is a 2-tuple, it specifies the axes that hold 2-D matrices, and the matrix norms of these matrices are computed. If `axis` is None then either a vector norm (when `x` is 1-D) or a matrix norm (when `x` is 2-D) is returned. The default is None. .. versionadded:: 1.8.0 keepdims : bool, optional If this is set to True, the axes which are normed over are left in the result as dimensions with size one. With this option the result will broadcast correctly against the original `x`. .. versionadded:: 1.10.0 Returns ------- n : float or ndarray Norm of the matrix or vector(s). See Also -------- scipy.linalg.norm : Similar function in SciPy. Notes ----- For values of ``ord < 1``, the result is, strictly speaking, not a mathematical 'norm', but it may still be useful for various numerical purposes. The following norms can be calculated: ===== ============================ ========================== ord norm for matrices norm for vectors ===== ============================ ========================== None Frobenius norm 2-norm 'fro' Frobenius norm -- 'nuc' nuclear norm -- inf max(sum(abs(x), axis=1)) max(abs(x)) -inf min(sum(abs(x), axis=1)) min(abs(x)) 0 -- sum(x != 0) 1 max(sum(abs(x), axis=0)) as below -1 min(sum(abs(x), axis=0)) as below 2 2-norm (largest sing. value) as below -2 smallest singular value as below other -- sum(abs(x)**ord)**(1./ord) ===== ============================ ========================== The Frobenius norm is given by [1]_: :math:`||A||_F = [\\sum_{i,j} abs(a_{i,j})^2]^{1/2}` The nuclear norm is the sum of the singular values. Both the Frobenius and nuclear norm orders are only defined for matrices and raise a ValueError when ``x.ndim != 2``. References ---------- .. [1] G. H. Golub and C. F. Van Loan, *Matrix Computations*, Baltimore, MD, Johns Hopkins University Press, 1985, pg. 15 Examples -------- >>> from numpy import linalg as LA >>> a = np.arange(9) - 4 >>> a array([-4, -3, -2, ..., 2, 3, 4]) >>> b = a.reshape((3, 3)) >>> b array([[-4, -3, -2], [-1, 0, 1], [ 2, 3, 4]]) >>> LA.norm(a) 7.745966692414834 >>> LA.norm(b) 7.745966692414834 >>> LA.norm(b, 'fro') 7.745966692414834 >>> LA.norm(a, np.inf) 4.0 >>> LA.norm(b, np.inf) 9.0 >>> LA.norm(a, -np.inf) 0.0 >>> LA.norm(b, -np.inf) 2.0 >>> LA.norm(a, 1) 20.0 >>> LA.norm(b, 1) 7.0 >>> LA.norm(a, -1) -4.6566128774142013e-010 >>> LA.norm(b, -1) 6.0 >>> LA.norm(a, 2) 7.745966692414834 >>> LA.norm(b, 2) 7.3484692283495345 >>> LA.norm(a, -2) 0.0 >>> LA.norm(b, -2) 1.8570331885190563e-016 # may vary >>> LA.norm(a, 3) 5.8480354764257312 # may vary >>> LA.norm(a, -3) 0.0 Using the `axis` argument to compute vector norms: >>> c = np.array([[ 1, 2, 3], ... [-1, 1, 4]]) >>> LA.norm(c, axis=0) array([ 1.41421356, 2.23606798, 5. ]) >>> LA.norm(c, axis=1) array([ 3.74165739, 4.24264069]) >>> LA.norm(c, ord=1, axis=1) array([ 6., 6.]) Using the `axis` argument to compute matrix norms: >>> m = np.arange(8).reshape(2,2,2) >>> LA.norm(m, axis=(1,2)) array([ 3.74165739, 11.22497216]) >>> LA.norm(m[0, :, :]), LA.norm(m[1, :, :]) (3.7416573867739413, 11.224972160321824) """ x = asarray(x) if not issubclass(x.dtype.type, (inexact, object_)): x = x.astype(float) # Immediately handle some default, simple, fast, and common cases. if axis is None: ndim = x.ndim if ((ord is None) or (ord in ('f', 'fro') and ndim == 2) or (ord == 2 and ndim == 1)): x = x.ravel(order='K') if isComplexType(x.dtype.type): sqnorm = dot(x.real, x.real) + dot(x.imag, x.imag) else: sqnorm = dot(x, x) ret = sqrt(sqnorm) if keepdims: ret = ret.reshape(ndim*[1]) return ret # Normalize the `axis` argument to a tuple. nd = x.ndim if axis is None: axis = tuple(range(nd)) elif not isinstance(axis, tuple): try: axis = int(axis) except Exception as e: raise TypeError("'axis' must be None, an integer or a tuple of integers") from e axis = (axis,) if len(axis) == 1: if ord == Inf: return abs(x).max(axis=axis, keepdims=keepdims) elif ord == -Inf: return abs(x).min(axis=axis, keepdims=keepdims) elif ord == 0: # Zero norm return (x != 0).astype(x.real.dtype).sum(axis=axis, keepdims=keepdims) elif ord == 1: # special case for speedup return add.reduce(abs(x), axis=axis, keepdims=keepdims) elif ord is None or ord == 2: # special case for speedup s = (x.conj() * x).real return sqrt(add.reduce(s, axis=axis, keepdims=keepdims)) # None of the str-type keywords for ord ('fro', 'nuc') # are valid for vectors elif isinstance(ord, str): raise ValueError(f"Invalid norm order '{ord}' for vectors") else: absx = abs(x) absx **= ord ret = add.reduce(absx, axis=axis, keepdims=keepdims) > ret **= (1 / ord) E RuntimeWarning: invalid value encountered in reciprocal absx = array([[1. , 0.5 , 0.33333333], [0.25 , 0.2 , 0.16666667]]) axis = (0,) keepdims = False nd = 2 ord = -1 ret = array([0.8 , 1.42857143, 2. ]) x = array([[1., 2., 3.], [4., 5., 6.]]) /usr/local/lib/python3.8/site-packages/numpy/linalg/linalg.py:2570: RuntimeWarning =============================== warnings summary =============================== ../../../../../../../local/lib/python3.8/site-packages/nose/importer.py:12 /usr/local/lib/python3.8/site-packages/nose/importer.py:12: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses from imp import find_module, load_module, acquire_lock, release_lock -- Docs: https://docs.pytest.org/en/stable/warnings.html =========================== short test summary info ============================ FAILED ../../core/tests/test_cpu_dispatcher.py::test_dispatcher - AssertionEr... FAILED ../../core/tests/test_multiarray.py::test_npymath_complex[complex64-inf-inf-npy_cabs-absolute] FAILED ../../core/tests/test_multiarray.py::test_npymath_complex[complex64-inf--inf-npy_cabs-absolute] FAILED ../../core/tests/test_multiarray.py::test_npymath_complex[complex64--inf-inf-npy_cabs-absolute] FAILED ../../core/tests/test_multiarray.py::test_npymath_complex[complex64--inf--inf-npy_cabs-absolute] FAILED ../../core/tests/test_multiarray.py::test_npymath_complex[complex128-inf-inf-npy_cabs-absolute] FAILED ../../core/tests/test_multiarray.py::test_npymath_complex[complex128-inf--inf-npy_cabs-absolute] FAILED ../../core/tests/test_multiarray.py::test_npymath_complex[complex128--inf-inf-npy_cabs-absolute] FAILED ../../core/tests/test_multiarray.py::test_npymath_complex[complex128--inf--inf-npy_cabs-absolute] FAILED ../../core/tests/test_multiarray.py::test_npymath_complex[complex256-inf-inf-npy_cabs-absolute] FAILED ../../core/tests/test_multiarray.py::test_npymath_complex[complex256-inf--inf-npy_cabs-absolute] FAILED ../../core/tests/test_multiarray.py::test_npymath_complex[complex256--inf-inf-npy_cabs-absolute] FAILED ../../core/tests/test_multiarray.py::test_npymath_complex[complex256--inf--inf-npy_cabs-absolute] FAILED ../../core/tests/test_scalarmath.py::TestBaseMath::test_blocked - Runt... FAILED ../../core/tests/test_ufunc.py::TestUfuncGenericLoops::test_unary_PyUFunc_O_O_method_full[reciprocal] FAILED ../../core/tests/test_umath.py::TestPower::test_power_float - RuntimeW... FAILED ../../core/tests/test_umath.py::TestAVXUfuncs::test_avx_based_ufunc - ... FAILED ../../core/tests/test_umath_complex.py::TestSpecialComplexAVX::test_array[complex64--1] FAILED ../../core/tests/test_umath_complex.py::TestSpecialComplexAVX::test_array[complex64-1] FAILED ../../core/tests/test_umath_complex.py::TestSpecialComplexAVX::test_array[complex128--1] FAILED ../../core/tests/test_umath_complex.py::TestSpecialComplexAVX::test_array[complex128-1] FAILED ../../linalg/tests/test_linalg.py::TestNormDouble::test_vector_return_type FAILED ../../linalg/tests/test_linalg.py::TestNormDouble::test_axis - Runtime... FAILED ../../linalg/tests/test_linalg.py::TestNormSingle::test_vector_return_type FAILED ../../linalg/tests/test_linalg.py::TestNormInt64::test_vector_return_type FAILED ../../linalg/tests/test_linalg.py::TestNormInt64::test_axis - RuntimeW... 26 failed, 14705 passed, 880 skipped, 1253 deselected, 19 xfailed, 3 xpassed, 1 warning in 304.34s (0:05:04)