tests/benchmarks/test-src/numpy_test_multiarray.py · bat

git.iko.soy/bat

on 3338699 help sign in

bat/tests/benchmarks/test-src/numpy_test_multiarray.py

8471 lines 317 kB history raw

1import collections.abc

2import tempfile

3import sys

4import shutil

5import warnings

6import operator

7import io

8import itertools

9import functools

10import ctypes

11import os

12import gc

13import weakref

14import pytest

15from contextlib import contextmanager

17from numpy.compat import pickle

19import pathlib

20import builtins

21from decimal import Decimal

23import numpy as np

24from numpy.compat import strchar

25import numpy.core._multiarray_tests as _multiarray_tests

26from numpy.testing import (

27 assert_, assert_raises, assert_warns, assert_equal, assert_almost_equal,

28 assert_array_equal, assert_raises_regex, assert_array_almost_equal,

29 assert_allclose, IS_PYPY, HAS_REFCOUNT, assert_array_less, runstring,

30 temppath, suppress_warnings, break_cycles,

31 )

32from numpy.testing._private.utils import _no_tracing

33from numpy.core.tests._locales import CommaDecimalPointLocale

35# Need to test an object that does not fully implement math interface

36from datetime import timedelta, datetime

39def _aligned_zeros(shape, dtype=float, order="C", align=None):

40 """

41 Allocate a new ndarray with aligned memory.

43 The ndarray is guaranteed *not* aligned to twice the requested alignment.

44 Eg, if align=4, guarantees it is not aligned to 8. If align=None uses

45 dtype.alignment."""

46 dtype = np.dtype(dtype)

47 if dtype == np.dtype(object):

48 # Can't do this, fall back to standard allocation (which

49 # should always be sufficiently aligned)

50 if align is not None:

51 raise ValueError("object array alignment not supported")

52 return np.zeros(shape, dtype=dtype, order=order)

53 if align is None:

54 align = dtype.alignment

55 if not hasattr(shape, '__len__'):

56 shape = (shape,)

57 size = functools.reduce(operator.mul, shape) * dtype.itemsize

58 buf = np.empty(size + 2*align + 1, np.uint8)

60 ptr = buf.__array_interface__['data'][0]

61 offset = ptr % align

62 if offset != 0:

63 offset = align - offset

64 if (ptr % (2*align)) == 0:

65 offset += align

67 # Note: slices producing 0-size arrays do not necessarily change

68 # data pointer --- so we use and allocate size+1

69 buf = buf[offset:offset+size+1][:-1]

70 data = np.ndarray(shape, dtype, buf, order=order)

71 data.fill(0)

72 return data

75class TestFlags:

76 def setup(self):

77 self.a = np.arange(10)

79 def test_writeable(self):

80 mydict = locals()

81 self.a.flags.writeable = False

82 assert_raises(ValueError, runstring, 'self.a[0] = 3', mydict)

83 assert_raises(ValueError, runstring, 'self.a[0:1].itemset(3)', mydict)

84 self.a.flags.writeable = True

85 self.a[0] = 5

86 self.a[0] = 0

88 def test_writeable_any_base(self):

89 # Ensure that any base being writeable is sufficient to change flag;

90 # this is especially interesting for arrays from an array interface.

91 arr = np.arange(10)

93 class subclass(np.ndarray):

94 pass

96 # Create subclass so base will not be collapsed, this is OK to change

97 view1 = arr.view(subclass)

98 view2 = view1[...]

99 arr.flags.writeable = False

100 view2.flags.writeable = False

101 view2.flags.writeable = True # Can be set to True again.

102

103 arr = np.arange(10)

104

105 class frominterface:

106 def __init__(self, arr):

107 self.arr = arr

108 self.__array_interface__ = arr.__array_interface__

109

110 view1 = np.asarray(frominterface)

111 view2 = view1[...]

112 view2.flags.writeable = False

113 view2.flags.writeable = True

114

115 view1.flags.writeable = False

116 view2.flags.writeable = False

117 with assert_raises(ValueError):

118 # Must assume not writeable, since only base is not:

119 view2.flags.writeable = True

120

121 def test_writeable_from_readonly(self):

122 # gh-9440 - make sure fromstring, from buffer on readonly buffers

123 # set writeable False

124 data = b'\x00' * 100

125 vals = np.frombuffer(data, 'B')

126 assert_raises(ValueError, vals.setflags, write=True)

127 types = np.dtype( [('vals', 'u1'), ('res3', 'S4')] )

128 values = np.core.records.fromstring(data, types)

129 vals = values['vals']

130 assert_raises(ValueError, vals.setflags, write=True)

131

132 def test_writeable_from_buffer(self):

133 data = bytearray(b'\x00' * 100)

134 vals = np.frombuffer(data, 'B')

135 assert_(vals.flags.writeable)

136 vals.setflags(write=False)

137 assert_(vals.flags.writeable is False)

138 vals.setflags(write=True)

139 assert_(vals.flags.writeable)

140 types = np.dtype( [('vals', 'u1'), ('res3', 'S4')] )

141 values = np.core.records.fromstring(data, types)

142 vals = values['vals']

143 assert_(vals.flags.writeable)

144 vals.setflags(write=False)

145 assert_(vals.flags.writeable is False)

146 vals.setflags(write=True)

147 assert_(vals.flags.writeable)

148

149 @pytest.mark.skipif(IS_PYPY, reason="PyPy always copies")

150 def test_writeable_pickle(self):

151 import pickle

152 # Small arrays will be copied without setting base.

153 # See condition for using PyArray_SetBaseObject in

154 # array_setstate.

155 a = np.arange(1000)

156 for v in range(pickle.HIGHEST_PROTOCOL):

157 vals = pickle.loads(pickle.dumps(a, v))

158 assert_(vals.flags.writeable)

159 assert_(isinstance(vals.base, bytes))

160

161 def test_writeable_from_c_data(self):

162 # Test that the writeable flag can be changed for an array wrapping

163 # low level C-data, but not owning its data.

164 # Also see that this is deprecated to change from python.

165 from numpy.core._multiarray_tests import get_c_wrapping_array

166

167 arr_writeable = get_c_wrapping_array(True)

168 assert not arr_writeable.flags.owndata

169 assert arr_writeable.flags.writeable

170 view = arr_writeable[...]

171

172 # Toggling the writeable flag works on the view:

173 view.flags.writeable = False

174 assert not view.flags.writeable

175 view.flags.writeable = True

176 assert view.flags.writeable

177 # Flag can be unset on the arr_writeable:

178 arr_writeable.flags.writeable = False

179

180 arr_readonly = get_c_wrapping_array(False)

181 assert not arr_readonly.flags.owndata

182 assert not arr_readonly.flags.writeable

183

184 for arr in [arr_writeable, arr_readonly]:

185 view = arr[...]

186 view.flags.writeable = False # make sure it is readonly

187 arr.flags.writeable = False

188 assert not arr.flags.writeable

189

190 with assert_raises(ValueError):

191 view.flags.writeable = True

192

193 with warnings.catch_warnings():

194 warnings.simplefilter("error", DeprecationWarning)

195 with assert_raises(DeprecationWarning):

196 arr.flags.writeable = True

197

198 with assert_warns(DeprecationWarning):

199 arr.flags.writeable = True

200

201 def test_warnonwrite(self):

202 a = np.arange(10)

203 a.flags._warn_on_write = True

204 with warnings.catch_warnings(record=True) as w:

205 warnings.filterwarnings('always')

206 a[1] = 10

207 a[2] = 10

208 # only warn once

209 assert_(len(w) == 1)

210

211 def test_otherflags(self):

212 assert_equal(self.a.flags.carray, True)

213 assert_equal(self.a.flags['C'], True)

214 assert_equal(self.a.flags.farray, False)

215 assert_equal(self.a.flags.behaved, True)

216 assert_equal(self.a.flags.fnc, False)

217 assert_equal(self.a.flags.forc, True)

218 assert_equal(self.a.flags.owndata, True)

219 assert_equal(self.a.flags.writeable, True)

220 assert_equal(self.a.flags.aligned, True)

221 with assert_warns(DeprecationWarning):

222 assert_equal(self.a.flags.updateifcopy, False)

223 with assert_warns(DeprecationWarning):

224 assert_equal(self.a.flags['U'], False)

225 assert_equal(self.a.flags['UPDATEIFCOPY'], False)

226 assert_equal(self.a.flags.writebackifcopy, False)

227 assert_equal(self.a.flags['X'], False)

228 assert_equal(self.a.flags['WRITEBACKIFCOPY'], False)

229

230 def test_string_align(self):

231 a = np.zeros(4, dtype=np.dtype('|S4'))

232 assert_(a.flags.aligned)

233 # not power of two are accessed byte-wise and thus considered aligned

234 a = np.zeros(5, dtype=np.dtype('|S4'))

235 assert_(a.flags.aligned)

236

237 def test_void_align(self):

238 a = np.zeros(4, dtype=np.dtype([("a", "i4"), ("b", "i4")]))

239 assert_(a.flags.aligned)

240

241

242class TestHash:

243 # see #3793

244 def test_int(self):

245 for st, ut, s in [(np.int8, np.uint8, 8),

246 (np.int16, np.uint16, 16),

247 (np.int32, np.uint32, 32),

248 (np.int64, np.uint64, 64)]:

249 for i in range(1, s):

250 assert_equal(hash(st(-2**i)), hash(-2**i),

251 err_msg="%r: -2**%d" % (st, i))

252 assert_equal(hash(st(2**(i - 1))), hash(2**(i - 1)),

253 err_msg="%r: 2**%d" % (st, i - 1))

254 assert_equal(hash(st(2**i - 1)), hash(2**i - 1),

255 err_msg="%r: 2**%d - 1" % (st, i))

256

257 i = max(i - 1, 1)

258 assert_equal(hash(ut(2**(i - 1))), hash(2**(i - 1)),

259 err_msg="%r: 2**%d" % (ut, i - 1))

260 assert_equal(hash(ut(2**i - 1)), hash(2**i - 1),

261 err_msg="%r: 2**%d - 1" % (ut, i))

262

263

264class TestAttributes:

265 def setup(self):

266 self.one = np.arange(10)

267 self.two = np.arange(20).reshape(4, 5)

268 self.three = np.arange(60, dtype=np.float64).reshape(2, 5, 6)

269

270 def test_attributes(self):

271 assert_equal(self.one.shape, (10,))

272 assert_equal(self.two.shape, (4, 5))

273 assert_equal(self.three.shape, (2, 5, 6))

274 self.three.shape = (10, 3, 2)

275 assert_equal(self.three.shape, (10, 3, 2))

276 self.three.shape = (2, 5, 6)

277 assert_equal(self.one.strides, (self.one.itemsize,))

278 num = self.two.itemsize

279 assert_equal(self.two.strides, (5*num, num))

280 num = self.three.itemsize

281 assert_equal(self.three.strides, (30*num, 6*num, num))

282 assert_equal(self.one.ndim, 1)

283 assert_equal(self.two.ndim, 2)

284 assert_equal(self.three.ndim, 3)

285 num = self.two.itemsize

286 assert_equal(self.two.size, 20)

287 assert_equal(self.two.nbytes, 20*num)

288 assert_equal(self.two.itemsize, self.two.dtype.itemsize)

289 assert_equal(self.two.base, np.arange(20))

290

291 def test_dtypeattr(self):

292 assert_equal(self.one.dtype, np.dtype(np.int_))

293 assert_equal(self.three.dtype, np.dtype(np.float_))

294 assert_equal(self.one.dtype.char, 'l')

295 assert_equal(self.three.dtype.char, 'd')

296 assert_(self.three.dtype.str[0] in '<>')

297 assert_equal(self.one.dtype.str[1], 'i')

298 assert_equal(self.three.dtype.str[1], 'f')

299

300 def test_int_subclassing(self):

301 # Regression test for https://github.com/numpy/numpy/pull/3526

302

303 numpy_int = np.int_(0)

304

305 # int_ doesn't inherit from Python int, because it's not fixed-width

306 assert_(not isinstance(numpy_int, int))

307

308 def test_stridesattr(self):

309 x = self.one

310

311 def make_array(size, offset, strides):

312 return np.ndarray(size, buffer=x, dtype=int,

313 offset=offset*x.itemsize,

314 strides=strides*x.itemsize)

315

316 assert_equal(make_array(4, 4, -1), np.array([4, 3, 2, 1]))

317 assert_raises(ValueError, make_array, 4, 4, -2)

318 assert_raises(ValueError, make_array, 4, 2, -1)

319 assert_raises(ValueError, make_array, 8, 3, 1)

320 assert_equal(make_array(8, 3, 0), np.array([3]*8))

321 # Check behavior reported in gh-2503:

322 assert_raises(ValueError, make_array, (2, 3), 5, np.array([-2, -3]))

323 make_array(0, 0, 10)

324

325 def test_set_stridesattr(self):

326 x = self.one

327

328 def make_array(size, offset, strides):

329 try:

330 r = np.ndarray([size], dtype=int, buffer=x,

331 offset=offset*x.itemsize)

332 except Exception as e:

333 raise RuntimeError(e)

334 r.strides = strides = strides*x.itemsize

335 return r

336

337 assert_equal(make_array(4, 4, -1), np.array([4, 3, 2, 1]))

338 assert_equal(make_array(7, 3, 1), np.array([3, 4, 5, 6, 7, 8, 9]))

339 assert_raises(ValueError, make_array, 4, 4, -2)

340 assert_raises(ValueError, make_array, 4, 2, -1)

341 assert_raises(RuntimeError, make_array, 8, 3, 1)

342 # Check that the true extent of the array is used.

343 # Test relies on as_strided base not exposing a buffer.

344 x = np.lib.stride_tricks.as_strided(np.arange(1), (10, 10), (0, 0))

345

346 def set_strides(arr, strides):

347 arr.strides = strides

348

349 assert_raises(ValueError, set_strides, x, (10*x.itemsize, x.itemsize))

350

351 # Test for offset calculations:

352 x = np.lib.stride_tricks.as_strided(np.arange(10, dtype=np.int8)[-1],

353 shape=(10,), strides=(-1,))

354 assert_raises(ValueError, set_strides, x[::-1], -1)

355 a = x[::-1]

356 a.strides = 1

357 a[::2].strides = 2

358

359 # test 0d

360 arr_0d = np.array(0)

361 arr_0d.strides = ()

362 assert_raises(TypeError, set_strides, arr_0d, None)

363

364 def test_fill(self):

365 for t in "?bhilqpBHILQPfdgFDGO":

366 x = np.empty((3, 2, 1), t)

367 y = np.empty((3, 2, 1), t)

368 x.fill(1)

369 y[...] = 1

370 assert_equal(x, y)

371

372 def test_fill_max_uint64(self):

373 x = np.empty((3, 2, 1), dtype=np.uint64)

374 y = np.empty((3, 2, 1), dtype=np.uint64)

375 value = 2**64 - 1

376 y[...] = value

377 x.fill(value)

378 assert_array_equal(x, y)

379

380 def test_fill_struct_array(self):

381 # Filling from a scalar

382 x = np.array([(0, 0.0), (1, 1.0)], dtype='i4,f8')

383 x.fill(x[0])

384 assert_equal(x['f1'][1], x['f1'][0])

385 # Filling from a tuple that can be converted

386 # to a scalar

387 x = np.zeros(2, dtype=[('a', 'f8'), ('b', 'i4')])

388 x.fill((3.5, -2))

389 assert_array_equal(x['a'], [3.5, 3.5])

390 assert_array_equal(x['b'], [-2, -2])

391

392

393class TestArrayConstruction:

394 def test_array(self):

395 d = np.ones(6)

396 r = np.array([d, d])

397 assert_equal(r, np.ones((2, 6)))

398

399 d = np.ones(6)

400 tgt = np.ones((2, 6))

401 r = np.array([d, d])

402 assert_equal(r, tgt)

403 tgt[1] = 2

404 r = np.array([d, d + 1])

405 assert_equal(r, tgt)

406

407 d = np.ones(6)

408 r = np.array([[d, d]])

409 assert_equal(r, np.ones((1, 2, 6)))

410

411 d = np.ones(6)

412 r = np.array([[d, d], [d, d]])

413 assert_equal(r, np.ones((2, 2, 6)))

414

415 d = np.ones((6, 6))

416 r = np.array([d, d])

417 assert_equal(r, np.ones((2, 6, 6)))

418

419 d = np.ones((6, ))

420 r = np.array([[d, d + 1], d + 2], dtype=object)

421 assert_equal(len(r), 2)

422 assert_equal(r[0], [d, d + 1])

423 assert_equal(r[1], d + 2)

424

425 tgt = np.ones((2, 3), dtype=bool)

426 tgt[0, 2] = False

427 tgt[1, 0:2] = False

428 r = np.array([[True, True, False], [False, False, True]])

429 assert_equal(r, tgt)

430 r = np.array([[True, False], [True, False], [False, True]])

431 assert_equal(r, tgt.T)

432

433 def test_array_empty(self):

434 assert_raises(TypeError, np.array)

435

436 def test_array_copy_false(self):

437 d = np.array([1, 2, 3])

438 e = np.array(d, copy=False)

439 d[1] = 3

440 assert_array_equal(e, [1, 3, 3])

441 e = np.array(d, copy=False, order='F')

442 d[1] = 4

443 assert_array_equal(e, [1, 4, 3])

444 e[2] = 7

445 assert_array_equal(d, [1, 4, 7])

446

447 def test_array_copy_true(self):

448 d = np.array([[1,2,3], [1, 2, 3]])

449 e = np.array(d, copy=True)

450 d[0, 1] = 3

451 e[0, 2] = -7

452 assert_array_equal(e, [[1, 2, -7], [1, 2, 3]])

453 assert_array_equal(d, [[1, 3, 3], [1, 2, 3]])

454 e = np.array(d, copy=True, order='F')

455 d[0, 1] = 5

456 e[0, 2] = 7

457 assert_array_equal(e, [[1, 3, 7], [1, 2, 3]])

458 assert_array_equal(d, [[1, 5, 3], [1,2,3]])

459

460 def test_array_cont(self):

461 d = np.ones(10)[::2]

462 assert_(np.ascontiguousarray(d).flags.c_contiguous)

463 assert_(np.ascontiguousarray(d).flags.f_contiguous)

464 assert_(np.asfortranarray(d).flags.c_contiguous)

465 assert_(np.asfortranarray(d).flags.f_contiguous)

466 d = np.ones((10, 10))[::2,::2]

467 assert_(np.ascontiguousarray(d).flags.c_contiguous)

468 assert_(np.asfortranarray(d).flags.f_contiguous)

469

470

471class TestAssignment:

472 def test_assignment_broadcasting(self):

473 a = np.arange(6).reshape(2, 3)

474

475 # Broadcasting the input to the output

476 a[...] = np.arange(3)

477 assert_equal(a, [[0, 1, 2], [0, 1, 2]])

478 a[...] = np.arange(2).reshape(2, 1)

479 assert_equal(a, [[0, 0, 0], [1, 1, 1]])

480

481 # For compatibility with <= 1.5, a limited version of broadcasting

482 # the output to the input.

483 #

484 # This behavior is inconsistent with NumPy broadcasting

485 # in general, because it only uses one of the two broadcasting

486 # rules (adding a new "1" dimension to the left of the shape),

487 # applied to the output instead of an input. In NumPy 2.0, this kind

488 # of broadcasting assignment will likely be disallowed.

489 a[...] = np.arange(6)[::-1].reshape(1, 2, 3)

490 assert_equal(a, [[5, 4, 3], [2, 1, 0]])

491 # The other type of broadcasting would require a reduction operation.

492

493 def assign(a, b):

494 a[...] = b

495

496 assert_raises(ValueError, assign, a, np.arange(12).reshape(2, 2, 3))

497

498 def test_assignment_errors(self):

499 # Address issue #2276

500 class C:

501 pass

502 a = np.zeros(1)

503

504 def assign(v):

505 a[0] = v

506

507 assert_raises((AttributeError, TypeError), assign, C())

508 assert_raises(ValueError, assign, [1])

509

510 def test_unicode_assignment(self):

511 # gh-5049

512 from numpy.core.numeric import set_string_function

513

514 @contextmanager

515 def inject_str(s):

516 """ replace ndarray.__str__ temporarily """

517 set_string_function(lambda x: s, repr=False)

518 try:

519 yield

520 finally:

521 set_string_function(None, repr=False)

522

523 a1d = np.array([u'test'])

524 a0d = np.array(u'done')

525 with inject_str(u'bad'):

526 a1d[0] = a0d # previously this would invoke __str__

527 assert_equal(a1d[0], u'done')

528

529 # this would crash for the same reason

530 np.array([np.array(u'\xe5\xe4\xf6')])

531

532 def test_stringlike_empty_list(self):

533 # gh-8902

534 u = np.array([u'done'])

535 b = np.array([b'done'])

536

537 class bad_sequence:

538 def __getitem__(self): pass

539 def __len__(self): raise RuntimeError

540

541 assert_raises(ValueError, operator.setitem, u, 0, [])

542 assert_raises(ValueError, operator.setitem, b, 0, [])

543

544 assert_raises(ValueError, operator.setitem, u, 0, bad_sequence())

545 assert_raises(ValueError, operator.setitem, b, 0, bad_sequence())

546

547 def test_longdouble_assignment(self):

548 # only relevant if longdouble is larger than float

549 # we're looking for loss of precision

550

551 for dtype in (np.longdouble, np.longcomplex):

552 # gh-8902

553 tinyb = np.nextafter(np.longdouble(0), 1).astype(dtype)

554 tinya = np.nextafter(np.longdouble(0), -1).astype(dtype)

555

556 # construction

557 tiny1d = np.array([tinya])

558 assert_equal(tiny1d[0], tinya)

559

560 # scalar = scalar

561 tiny1d[0] = tinyb

562 assert_equal(tiny1d[0], tinyb)

563

564 # 0d = scalar

565 tiny1d[0, ...] = tinya

566 assert_equal(tiny1d[0], tinya)

567

568 # 0d = 0d

569 tiny1d[0, ...] = tinyb[...]

570 assert_equal(tiny1d[0], tinyb)

571

572 # scalar = 0d

573 tiny1d[0] = tinyb[...]

574 assert_equal(tiny1d[0], tinyb)

575

576 arr = np.array([np.array(tinya)])

577 assert_equal(arr[0], tinya)

578

579 def test_cast_to_string(self):

580 # cast to str should do "str(scalar)", not "str(scalar.item())"

581 # Example: In python2, str(float) is truncated, so we want to avoid

582 # str(np.float64(...).item()) as this would incorrectly truncate.

583 a = np.zeros(1, dtype='S20')

584 a[:] = np.array(['1.12345678901234567890'], dtype='f8')

585 assert_equal(a[0], b"1.1234567890123457")

586

587

588class TestDtypedescr:

589 def test_construction(self):

590 d1 = np.dtype('i4')

591 assert_equal(d1, np.dtype(np.int32))

592 d2 = np.dtype('f8')

593 assert_equal(d2, np.dtype(np.float64))

594

595 def test_byteorders(self):

596 assert_(np.dtype('<i4') != np.dtype('>i4'))

597 assert_(np.dtype([('a', '<i4')]) != np.dtype([('a', '>i4')]))

598

599 def test_structured_non_void(self):

600 fields = [('a', '<i2'), ('b', '<i2')]

601 dt_int = np.dtype(('i4', fields))

602 assert_equal(str(dt_int), "(numpy.int32, [('a', '<i2'), ('b', '<i2')])")

603

604 # gh-9821

605 arr_int = np.zeros(4, dt_int)

606 assert_equal(repr(arr_int),

607 "array([0, 0, 0, 0], dtype=(numpy.int32, [('a', '<i2'), ('b', '<i2')]))")

608

609

610class TestZeroRank:

611 def setup(self):

612 self.d = np.array(0), np.array('x', object)

613

614 def test_ellipsis_subscript(self):

615 a, b = self.d

616 assert_equal(a[...], 0)

617 assert_equal(b[...], 'x')

618 assert_(a[...].base is a) # `a[...] is a` in numpy <1.9.

619 assert_(b[...].base is b) # `b[...] is b` in numpy <1.9.

620

621 def test_empty_subscript(self):

622 a, b = self.d

623 assert_equal(a[()], 0)

624 assert_equal(b[()], 'x')

625 assert_(type(a[()]) is a.dtype.type)

626 assert_(type(b[()]) is str)

627

628 def test_invalid_subscript(self):

629 a, b = self.d

630 assert_raises(IndexError, lambda x: x[0], a)

631 assert_raises(IndexError, lambda x: x[0], b)

632 assert_raises(IndexError, lambda x: x[np.array([], int)], a)

633 assert_raises(IndexError, lambda x: x[np.array([], int)], b)

634

635 def test_ellipsis_subscript_assignment(self):

636 a, b = self.d

637 a[...] = 42

638 assert_equal(a, 42)

639 b[...] = ''

640 assert_equal(b.item(), '')

641

642 def test_empty_subscript_assignment(self):

643 a, b = self.d

644 a[()] = 42

645 assert_equal(a, 42)

646 b[()] = ''

647 assert_equal(b.item(), '')

648

649 def test_invalid_subscript_assignment(self):

650 a, b = self.d

651

652 def assign(x, i, v):

653 x[i] = v

654

655 assert_raises(IndexError, assign, a, 0, 42)

656 assert_raises(IndexError, assign, b, 0, '')

657 assert_raises(ValueError, assign, a, (), '')

658

659 def test_newaxis(self):

660 a, b = self.d

661 assert_equal(a[np.newaxis].shape, (1,))

662 assert_equal(a[..., np.newaxis].shape, (1,))

663 assert_equal(a[np.newaxis, ...].shape, (1,))

664 assert_equal(a[..., np.newaxis].shape, (1,))

665 assert_equal(a[np.newaxis, ..., np.newaxis].shape, (1, 1))

666 assert_equal(a[..., np.newaxis, np.newaxis].shape, (1, 1))

667 assert_equal(a[np.newaxis, np.newaxis, ...].shape, (1, 1))

668 assert_equal(a[(np.newaxis,)*10].shape, (1,)*10)

669

670 def test_invalid_newaxis(self):

671 a, b = self.d

672

673 def subscript(x, i):

674 x[i]

675

676 assert_raises(IndexError, subscript, a, (np.newaxis, 0))

677 assert_raises(IndexError, subscript, a, (np.newaxis,)*50)

678

679 def test_constructor(self):

680 x = np.ndarray(())

681 x[()] = 5

682 assert_equal(x[()], 5)

683 y = np.ndarray((), buffer=x)

684 y[()] = 6

685 assert_equal(x[()], 6)

686

687 # strides and shape must be the same length

688 with pytest.raises(ValueError):

689 np.ndarray((2,), strides=())

690 with pytest.raises(ValueError):

691 np.ndarray((), strides=(2,))

692

693 def test_output(self):

694 x = np.array(2)

695 assert_raises(ValueError, np.add, x, [1], x)

696

697 def test_real_imag(self):

698 # contiguity checks are for gh-11245

699 x = np.array(1j)

700 xr = x.real

701 xi = x.imag

702

703 assert_equal(xr, np.array(0))

704 assert_(type(xr) is np.ndarray)

705 assert_equal(xr.flags.contiguous, True)

706 assert_equal(xr.flags.f_contiguous, True)

707

708 assert_equal(xi, np.array(1))

709 assert_(type(xi) is np.ndarray)

710 assert_equal(xi.flags.contiguous, True)

711 assert_equal(xi.flags.f_contiguous, True)

712

713

714class TestScalarIndexing:

715 def setup(self):

716 self.d = np.array([0, 1])[0]

717

718 def test_ellipsis_subscript(self):

719 a = self.d

720 assert_equal(a[...], 0)

721 assert_equal(a[...].shape, ())

722

723 def test_empty_subscript(self):

724 a = self.d

725 assert_equal(a[()], 0)

726 assert_equal(a[()].shape, ())

727

728 def test_invalid_subscript(self):

729 a = self.d

730 assert_raises(IndexError, lambda x: x[0], a)

731 assert_raises(IndexError, lambda x: x[np.array([], int)], a)

732

733 def test_invalid_subscript_assignment(self):

734 a = self.d

735

736 def assign(x, i, v):

737 x[i] = v

738

739 assert_raises(TypeError, assign, a, 0, 42)

740

741 def test_newaxis(self):

742 a = self.d

743 assert_equal(a[np.newaxis].shape, (1,))

744 assert_equal(a[..., np.newaxis].shape, (1,))

745 assert_equal(a[np.newaxis, ...].shape, (1,))

746 assert_equal(a[..., np.newaxis].shape, (1,))

747 assert_equal(a[np.newaxis, ..., np.newaxis].shape, (1, 1))

748 assert_equal(a[..., np.newaxis, np.newaxis].shape, (1, 1))

749 assert_equal(a[np.newaxis, np.newaxis, ...].shape, (1, 1))

750 assert_equal(a[(np.newaxis,)*10].shape, (1,)*10)

751

752 def test_invalid_newaxis(self):

753 a = self.d

754

755 def subscript(x, i):

756 x[i]

757

758 assert_raises(IndexError, subscript, a, (np.newaxis, 0))

759 assert_raises(IndexError, subscript, a, (np.newaxis,)*50)

760

761 def test_overlapping_assignment(self):

762 # With positive strides

763 a = np.arange(4)

764 a[:-1] = a[1:]

765 assert_equal(a, [1, 2, 3, 3])

766

767 a = np.arange(4)

768 a[1:] = a[:-1]

769 assert_equal(a, [0, 0, 1, 2])

770

771 # With positive and negative strides

772 a = np.arange(4)

773 a[:] = a[::-1]

774 assert_equal(a, [3, 2, 1, 0])

775

776 a = np.arange(6).reshape(2, 3)

777 a[::-1,:] = a[:, ::-1]

778 assert_equal(a, [[5, 4, 3], [2, 1, 0]])

779

780 a = np.arange(6).reshape(2, 3)

781 a[::-1, ::-1] = a[:, ::-1]

782 assert_equal(a, [[3, 4, 5], [0, 1, 2]])

783

784 # With just one element overlapping

785 a = np.arange(5)

786 a[:3] = a[2:]

787 assert_equal(a, [2, 3, 4, 3, 4])

788

789 a = np.arange(5)

790 a[2:] = a[:3]

791 assert_equal(a, [0, 1, 0, 1, 2])

792

793 a = np.arange(5)

794 a[2::-1] = a[2:]

795 assert_equal(a, [4, 3, 2, 3, 4])

796

797 a = np.arange(5)

798 a[2:] = a[2::-1]

799 assert_equal(a, [0, 1, 2, 1, 0])

800

801 a = np.arange(5)

802 a[2::-1] = a[:1:-1]

803 assert_equal(a, [2, 3, 4, 3, 4])

804

805 a = np.arange(5)

806 a[:1:-1] = a[2::-1]

807 assert_equal(a, [0, 1, 0, 1, 2])

808

809

810class TestCreation:

811 """

812 Test the np.array constructor

813 """

814 def test_from_attribute(self):

815 class x:

816 def __array__(self, dtype=None):

817 pass

818

819 assert_raises(ValueError, np.array, x())

820

821 def test_from_string(self):

822 types = np.typecodes['AllInteger'] + np.typecodes['Float']

823 nstr = ['123', '123']

824 result = np.array([123, 123], dtype=int)

825 for type in types:

826 msg = 'String conversion for %s' % type

827 assert_equal(np.array(nstr, dtype=type), result, err_msg=msg)

828

829 def test_void(self):

830 arr = np.array([], dtype='V')

831 assert_equal(arr.dtype.kind, 'V')

832

833 def test_too_big_error(self):

834 # 45341 is the smallest integer greater than sqrt(2**31 - 1).

835 # 3037000500 is the smallest integer greater than sqrt(2**63 - 1).

836 # We want to make sure that the square byte array with those dimensions

837 # is too big on 32 or 64 bit systems respectively.

838 if np.iinfo('intp').max == 2**31 - 1:

839 shape = (46341, 46341)

840 elif np.iinfo('intp').max == 2**63 - 1:

841 shape = (3037000500, 3037000500)

842 else:

843 return

844 assert_raises(ValueError, np.empty, shape, dtype=np.int8)

845 assert_raises(ValueError, np.zeros, shape, dtype=np.int8)

846 assert_raises(ValueError, np.ones, shape, dtype=np.int8)

847

848 @pytest.mark.skipif(np.dtype(np.intp).itemsize != 8,

849 reason="malloc may not fail on 32 bit systems")

850 def test_malloc_fails(self):

851 # This test is guaranteed to fail due to a too large allocation

852 with assert_raises(np.core._exceptions._ArrayMemoryError):

853 np.empty(np.iinfo(np.intp).max, dtype=np.uint8)

854

855 def test_zeros(self):

856 types = np.typecodes['AllInteger'] + np.typecodes['AllFloat']

857 for dt in types:

858 d = np.zeros((13,), dtype=dt)

859 assert_equal(np.count_nonzero(d), 0)

860 # true for ieee floats

861 assert_equal(d.sum(), 0)

862 assert_(not d.any())

863

864 d = np.zeros(2, dtype='(2,4)i4')

865 assert_equal(np.count_nonzero(d), 0)

866 assert_equal(d.sum(), 0)

867 assert_(not d.any())

868

869 d = np.zeros(2, dtype='4i4')

870 assert_equal(np.count_nonzero(d), 0)

871 assert_equal(d.sum(), 0)

872 assert_(not d.any())

873

874 d = np.zeros(2, dtype='(2,4)i4, (2,4)i4')

875 assert_equal(np.count_nonzero(d), 0)

876

877 @pytest.mark.slow

878 def test_zeros_big(self):

879 # test big array as they might be allocated different by the system

880 types = np.typecodes['AllInteger'] + np.typecodes['AllFloat']

881 for dt in types:

882 d = np.zeros((30 * 1024**2,), dtype=dt)

883 assert_(not d.any())

884 # This test can fail on 32-bit systems due to insufficient

885 # contiguous memory. Deallocating the previous array increases the

886 # chance of success.

887 del(d)

888

889 def test_zeros_obj(self):

890 # test initialization from PyLong(0)

891 d = np.zeros((13,), dtype=object)

892 assert_array_equal(d, [0] * 13)

893 assert_equal(np.count_nonzero(d), 0)

894

895 def test_zeros_obj_obj(self):

896 d = np.zeros(10, dtype=[('k', object, 2)])

897 assert_array_equal(d['k'], 0)

898

899 def test_zeros_like_like_zeros(self):

900 # test zeros_like returns the same as zeros

901 for c in np.typecodes['All']:

902 if c == 'V':

903 continue

904 d = np.zeros((3,3), dtype=c)

905 assert_array_equal(np.zeros_like(d), d)

906 assert_equal(np.zeros_like(d).dtype, d.dtype)

907 # explicitly check some special cases

908 d = np.zeros((3,3), dtype='S5')

909 assert_array_equal(np.zeros_like(d), d)

910 assert_equal(np.zeros_like(d).dtype, d.dtype)

911 d = np.zeros((3,3), dtype='U5')

912 assert_array_equal(np.zeros_like(d), d)

913 assert_equal(np.zeros_like(d).dtype, d.dtype)

914

915 d = np.zeros((3,3), dtype='<i4')

916 assert_array_equal(np.zeros_like(d), d)

917 assert_equal(np.zeros_like(d).dtype, d.dtype)

918 d = np.zeros((3,3), dtype='>i4')

919 assert_array_equal(np.zeros_like(d), d)

920 assert_equal(np.zeros_like(d).dtype, d.dtype)

921

922 d = np.zeros((3,3), dtype='<M8[s]')

923 assert_array_equal(np.zeros_like(d), d)

924 assert_equal(np.zeros_like(d).dtype, d.dtype)

925 d = np.zeros((3,3), dtype='>M8[s]')

926 assert_array_equal(np.zeros_like(d), d)

927 assert_equal(np.zeros_like(d).dtype, d.dtype)

928

929 d = np.zeros((3,3), dtype='f4,f4')

930 assert_array_equal(np.zeros_like(d), d)

931 assert_equal(np.zeros_like(d).dtype, d.dtype)

932

933 def test_empty_unicode(self):

934 # don't throw decode errors on garbage memory

935 for i in range(5, 100, 5):

936 d = np.empty(i, dtype='U')

937 str(d)

938

939 def test_sequence_non_homogenous(self):

940 assert_equal(np.array([4, 2**80]).dtype, object)

941 assert_equal(np.array([4, 2**80, 4]).dtype, object)

942 assert_equal(np.array([2**80, 4]).dtype, object)

943 assert_equal(np.array([2**80] * 3).dtype, object)

944 assert_equal(np.array([[1, 1],[1j, 1j]]).dtype, complex)

945 assert_equal(np.array([[1j, 1j],[1, 1]]).dtype, complex)

946 assert_equal(np.array([[1, 1, 1],[1, 1j, 1.], [1, 1, 1]]).dtype, complex)

947

948 def test_non_sequence_sequence(self):

949 """Should not segfault.

950

951 Class Fail breaks the sequence protocol for new style classes, i.e.,

952 those derived from object. Class Map is a mapping type indicated by

953 raising a ValueError. At some point we may raise a warning instead

954 of an error in the Fail case.

955

956 """

957 class Fail:

958 def __len__(self):

959 return 1

960

961 def __getitem__(self, index):

962 raise ValueError()

963

964 class Map:

965 def __len__(self):

966 return 1

967

968 def __getitem__(self, index):

969 raise KeyError()

970

971 a = np.array([Map()])

972 assert_(a.shape == (1,))

973 assert_(a.dtype == np.dtype(object))

974 assert_raises(ValueError, np.array, [Fail()])

975

976 def test_no_len_object_type(self):

977 # gh-5100, want object array from iterable object without len()

978 class Point2:

979 def __init__(self):

980 pass

981

982 def __getitem__(self, ind):

983 if ind in [0, 1]:

984 return ind

985 else:

986 raise IndexError()

987 d = np.array([Point2(), Point2(), Point2()])

988 assert_equal(d.dtype, np.dtype(object))

989

990 def test_false_len_sequence(self):

991 # gh-7264, segfault for this example

992 class C:

993 def __getitem__(self, i):

994 raise IndexError

995 def __len__(self):

996 return 42

997

998 a = np.array(C()) # segfault?

999 assert_equal(len(a), 0)

1000

1001 def test_false_len_iterable(self):

1002 # Special case where a bad __getitem__ makes us fall back on __iter__:

1003 class C:

1004 def __getitem__(self, x):

1005 raise Exception

1006 def __iter__(self):

1007 return iter(())

1008 def __len__(self):

1009 return 2

1010

1011 a = np.empty(2)

1012 with assert_raises(ValueError):

1013 a[:] = C() # Segfault!

1014

1015 def test_failed_len_sequence(self):

1016 # gh-7393

1017 class A:

1018 def __init__(self, data):

1019 self._data = data

1020 def __getitem__(self, item):

1021 return type(self)(self._data[item])

1022 def __len__(self):

1023 return len(self._data)

1024

1025 # len(d) should give 3, but len(d[0]) will fail

1026 d = A([1,2,3])

1027 assert_equal(len(np.array(d)), 3)

1028

1029 def test_array_too_big(self):

1030 # Test that array creation succeeds for arrays addressable by intp

1031 # on the byte level and fails for too large arrays.

1032 buf = np.zeros(100)

1033

1034 max_bytes = np.iinfo(np.intp).max

1035 for dtype in ["intp", "S20", "b"]:

1036 dtype = np.dtype(dtype)

1037 itemsize = dtype.itemsize

1038

1039 np.ndarray(buffer=buf, strides=(0,),

1040 shape=(max_bytes//itemsize,), dtype=dtype)

1041 assert_raises(ValueError, np.ndarray, buffer=buf, strides=(0,),

1042 shape=(max_bytes//itemsize + 1,), dtype=dtype)

1043

1044 def _ragged_creation(self, seq):

1045 # without dtype=object, the ragged object should raise

1046 with assert_warns(np.VisibleDeprecationWarning):

1047 a = np.array(seq)

1048 b = np.array(seq, dtype=object)

1049 assert_equal(a, b)

1050 return b

1051

1052 def test_ragged_ndim_object(self):

1053 # Lists of mismatching depths are treated as object arrays

1054 a = self._ragged_creation([[1], 2, 3])

1055 assert_equal(a.shape, (3,))

1056 assert_equal(a.dtype, object)

1057

1058 a = self._ragged_creation([1, [2], 3])

1059 assert_equal(a.shape, (3,))

1060 assert_equal(a.dtype, object)

1061

1062 a = self._ragged_creation([1, 2, [3]])

1063 assert_equal(a.shape, (3,))

1064 assert_equal(a.dtype, object)

1065

1066 def test_ragged_shape_object(self):

1067 # The ragged dimension of a list is turned into an object array

1068 a = self._ragged_creation([[1, 1], [2], [3]])

1069 assert_equal(a.shape, (3,))

1070 assert_equal(a.dtype, object)

1071

1072 a = self._ragged_creation([[1], [2, 2], [3]])

1073 assert_equal(a.shape, (3,))

1074 assert_equal(a.dtype, object)

1075

1076 a = self._ragged_creation([[1], [2], [3, 3]])

1077 assert a.shape == (3,)

1078 assert a.dtype == object

1079

1080 def test_array_of_ragged_array(self):

1081 outer = np.array([None, None])

1082 outer[0] = outer[1] = np.array([1, 2, 3])

1083 assert np.array(outer).shape == (2,)

1084 assert np.array([outer]).shape == (1, 2)

1085

1086 outer_ragged = np.array([None, None])

1087 outer_ragged[0] = np.array([1, 2, 3])

1088 outer_ragged[1] = np.array([1, 2, 3, 4])

1089 # should both of these emit deprecation warnings?

1090 assert np.array(outer_ragged).shape == (2,)

1091 assert np.array([outer_ragged]).shape == (1, 2,)

1092

1093 def test_deep_nonragged_object(self):

1094 # None of these should raise, even though they are missing dtype=object

1095 a = np.array([[[Decimal(1)]]])

1096 a = np.array([1, Decimal(1)])

1097 a = np.array([[1], [Decimal(1)]])

1098

1099class TestStructured:

1100 def test_subarray_field_access(self):

1101 a = np.zeros((3, 5), dtype=[('a', ('i4', (2, 2)))])

1102 a['a'] = np.arange(60).reshape(3, 5, 2, 2)

1103

1104 # Since the subarray is always in C-order, a transpose

1105 # does not swap the subarray:

1106 assert_array_equal(a.T['a'], a['a'].transpose(1, 0, 2, 3))

1107

1108 # In Fortran order, the subarray gets appended

1109 # like in all other cases, not prepended as a special case

1110 b = a.copy(order='F')

1111 assert_equal(a['a'].shape, b['a'].shape)

1112 assert_equal(a.T['a'].shape, a.T.copy()['a'].shape)

1113

1114 def test_subarray_comparison(self):

1115 # Check that comparisons between record arrays with

1116 # multi-dimensional field types work properly

1117 a = np.rec.fromrecords(

1118 [([1, 2, 3], 'a', [[1, 2], [3, 4]]), ([3, 3, 3], 'b', [[0, 0], [0, 0]])],

1119 dtype=[('a', ('f4', 3)), ('b', object), ('c', ('i4', (2, 2)))])

1120 b = a.copy()

1121 assert_equal(a == b, [True, True])

1122 assert_equal(a != b, [False, False])

1123 b[1].b = 'c'

1124 assert_equal(a == b, [True, False])

1125 assert_equal(a != b, [False, True])

1126 for i in range(3):

1127 b[0].a = a[0].a

1128 b[0].a[i] = 5

1129 assert_equal(a == b, [False, False])

1130 assert_equal(a != b, [True, True])

1131 for i in range(2):

1132 for j in range(2):

1133 b = a.copy()

1134 b[0].c[i, j] = 10

1135 assert_equal(a == b, [False, True])

1136 assert_equal(a != b, [True, False])

1137

1138 # Check that broadcasting with a subarray works

1139 a = np.array([[(0,)], [(1,)]], dtype=[('a', 'f8')])

1140 b = np.array([(0,), (0,), (1,)], dtype=[('a', 'f8')])

1141 assert_equal(a == b, [[True, True, False], [False, False, True]])

1142 assert_equal(b == a, [[True, True, False], [False, False, True]])

1143 a = np.array([[(0,)], [(1,)]], dtype=[('a', 'f8', (1,))])

1144 b = np.array([(0,), (0,), (1,)], dtype=[('a', 'f8', (1,))])

1145 assert_equal(a == b, [[True, True, False], [False, False, True]])

1146 assert_equal(b == a, [[True, True, False], [False, False, True]])

1147 a = np.array([[([0, 0],)], [([1, 1],)]], dtype=[('a', 'f8', (2,))])

1148 b = np.array([([0, 0],), ([0, 1],), ([1, 1],)], dtype=[('a', 'f8', (2,))])

1149 assert_equal(a == b, [[True, False, False], [False, False, True]])

1150 assert_equal(b == a, [[True, False, False], [False, False, True]])

1151

1152 # Check that broadcasting Fortran-style arrays with a subarray work

1153 a = np.array([[([0, 0],)], [([1, 1],)]], dtype=[('a', 'f8', (2,))], order='F')

1154 b = np.array([([0, 0],), ([0, 1],), ([1, 1],)], dtype=[('a', 'f8', (2,))])

1155 assert_equal(a == b, [[True, False, False], [False, False, True]])

1156 assert_equal(b == a, [[True, False, False], [False, False, True]])

1157

1158 # Check that incompatible sub-array shapes don't result to broadcasting

1159 x = np.zeros((1,), dtype=[('a', ('f4', (1, 2))), ('b', 'i1')])

1160 y = np.zeros((1,), dtype=[('a', ('f4', (2,))), ('b', 'i1')])

1161 # This comparison invokes deprecated behaviour, and will probably

1162 # start raising an error eventually. What we really care about in this

1163 # test is just that it doesn't return True.

1164 with suppress_warnings() as sup:

1165 sup.filter(FutureWarning, "elementwise == comparison failed")

1166 assert_equal(x == y, False)

1167

1168 x = np.zeros((1,), dtype=[('a', ('f4', (2, 1))), ('b', 'i1')])

1169 y = np.zeros((1,), dtype=[('a', ('f4', (2,))), ('b', 'i1')])

1170 # This comparison invokes deprecated behaviour, and will probably

1171 # start raising an error eventually. What we really care about in this

1172 # test is just that it doesn't return True.

1173 with suppress_warnings() as sup:

1174 sup.filter(FutureWarning, "elementwise == comparison failed")

1175 assert_equal(x == y, False)

1176

1177 # Check that structured arrays that are different only in

1178 # byte-order work

1179 a = np.array([(5, 42), (10, 1)], dtype=[('a', '>i8'), ('b', '<f8')])

1180 b = np.array([(5, 43), (10, 1)], dtype=[('a', '<i8'), ('b', '>f8')])

1181 assert_equal(a == b, [False, True])

1182

1183 def test_casting(self):

1184 # Check that casting a structured array to change its byte order

1185 # works

1186 a = np.array([(1,)], dtype=[('a', '<i4')])

1187 assert_(np.can_cast(a.dtype, [('a', '>i4')], casting='unsafe'))

1188 b = a.astype([('a', '>i4')])

1189 assert_equal(b, a.byteswap().newbyteorder())

1190 assert_equal(a['a'][0], b['a'][0])

1191

1192 # Check that equality comparison works on structured arrays if

1193 # they are 'equiv'-castable

1194 a = np.array([(5, 42), (10, 1)], dtype=[('a', '>i4'), ('b', '<f8')])

1195 b = np.array([(5, 42), (10, 1)], dtype=[('a', '<i4'), ('b', '>f8')])

1196 assert_(np.can_cast(a.dtype, b.dtype, casting='equiv'))

1197 assert_equal(a == b, [True, True])

1198

1199 # Check that 'equiv' casting can change byte order

1200 assert_(np.can_cast(a.dtype, b.dtype, casting='equiv'))

1201 c = a.astype(b.dtype, casting='equiv')

1202 assert_equal(a == c, [True, True])

1203

1204 # Check that 'safe' casting can change byte order and up-cast

1205 # fields

1206 t = [('a', '<i8'), ('b', '>f8')]

1207 assert_(np.can_cast(a.dtype, t, casting='safe'))

1208 c = a.astype(t, casting='safe')

1209 assert_equal((c == np.array([(5, 42), (10, 1)], dtype=t)),

1210 [True, True])

1211

1212 # Check that 'same_kind' casting can change byte order and

1213 # change field widths within a "kind"

1214 t = [('a', '<i4'), ('b', '>f4')]

1215 assert_(np.can_cast(a.dtype, t, casting='same_kind'))

1216 c = a.astype(t, casting='same_kind')

1217 assert_equal((c == np.array([(5, 42), (10, 1)], dtype=t)),

1218 [True, True])

1219

1220 # Check that casting fails if the casting rule should fail on

1221 # any of the fields

1222 t = [('a', '>i8'), ('b', '<f4')]

1223 assert_(not np.can_cast(a.dtype, t, casting='safe'))

1224 assert_raises(TypeError, a.astype, t, casting='safe')

1225 t = [('a', '>i2'), ('b', '<f8')]

1226 assert_(not np.can_cast(a.dtype, t, casting='equiv'))

1227 assert_raises(TypeError, a.astype, t, casting='equiv')

1228 t = [('a', '>i8'), ('b', '<i2')]

1229 assert_(not np.can_cast(a.dtype, t, casting='same_kind'))

1230 assert_raises(TypeError, a.astype, t, casting='same_kind')

1231 assert_(not np.can_cast(a.dtype, b.dtype, casting='no'))

1232 assert_raises(TypeError, a.astype, b.dtype, casting='no')

1233

1234 # Check that non-'unsafe' casting can't change the set of field names

1235 for casting in ['no', 'safe', 'equiv', 'same_kind']:

1236 t = [('a', '>i4')]

1237 assert_(not np.can_cast(a.dtype, t, casting=casting))

1238 t = [('a', '>i4'), ('b', '<f8'), ('c', 'i4')]

1239 assert_(not np.can_cast(a.dtype, t, casting=casting))

1240

1241 def test_objview(self):

1242 # https://github.com/numpy/numpy/issues/3286

1243 a = np.array([], dtype=[('a', 'f'), ('b', 'f'), ('c', 'O')])

1244 a[['a', 'b']] # TypeError?

1245

1246 # https://github.com/numpy/numpy/issues/3253

1247 dat2 = np.zeros(3, [('A', 'i'), ('B', '|O')])

1248 dat2[['B', 'A']] # TypeError?

1249

1250 def test_setfield(self):

1251 # https://github.com/numpy/numpy/issues/3126

1252 struct_dt = np.dtype([('elem', 'i4', 5),])

1253 dt = np.dtype([('field', 'i4', 10),('struct', struct_dt)])

1254 x = np.zeros(1, dt)

1255 x[0]['field'] = np.ones(10, dtype='i4')

1256 x[0]['struct'] = np.ones(1, dtype=struct_dt)

1257 assert_equal(x[0]['field'], np.ones(10, dtype='i4'))

1258

1259 def test_setfield_object(self):

1260 # make sure object field assignment with ndarray value

1261 # on void scalar mimics setitem behavior

1262 b = np.zeros(1, dtype=[('x', 'O')])

1263 # next line should work identically to b['x'][0] = np.arange(3)

1264 b[0]['x'] = np.arange(3)

1265 assert_equal(b[0]['x'], np.arange(3))

1266

1267 # check that broadcasting check still works

1268 c = np.zeros(1, dtype=[('x', 'O', 5)])

1269

1270 def testassign():

1271 c[0]['x'] = np.arange(3)

1272

1273 assert_raises(ValueError, testassign)

1274

1275 def test_zero_width_string(self):

1276 # Test for PR #6430 / issues #473, #4955, #2585

1277

1278 dt = np.dtype([('I', int), ('S', 'S0')])

1279

1280 x = np.zeros(4, dtype=dt)

1281

1282 assert_equal(x['S'], [b'', b'', b'', b''])

1283 assert_equal(x['S'].itemsize, 0)

1284

1285 x['S'] = ['a', 'b', 'c', 'd']

1286 assert_equal(x['S'], [b'', b'', b'', b''])

1287 assert_equal(x['I'], [0, 0, 0, 0])

1288

1289 # Variation on test case from #4955

1290 x['S'][x['I'] == 0] = 'hello'

1291 assert_equal(x['S'], [b'', b'', b'', b''])

1292 assert_equal(x['I'], [0, 0, 0, 0])

1293

1294 # Variation on test case from #2585

1295 x['S'] = 'A'

1296 assert_equal(x['S'], [b'', b'', b'', b''])

1297 assert_equal(x['I'], [0, 0, 0, 0])

1298

1299 # Allow zero-width dtypes in ndarray constructor

1300 y = np.ndarray(4, dtype=x['S'].dtype)

1301 assert_equal(y.itemsize, 0)

1302 assert_equal(x['S'], y)

1303

1304 # More tests for indexing an array with zero-width fields

1305 assert_equal(np.zeros(4, dtype=[('a', 'S0,S0'),

1306 ('b', 'u1')])['a'].itemsize, 0)

1307 assert_equal(np.empty(3, dtype='S0,S0').itemsize, 0)

1308 assert_equal(np.zeros(4, dtype='S0,u1')['f0'].itemsize, 0)

1309

1310 xx = x['S'].reshape((2, 2))

1311 assert_equal(xx.itemsize, 0)

1312 assert_equal(xx, [[b'', b''], [b'', b'']])

1313 # check for no uninitialized memory due to viewing S0 array

1314 assert_equal(xx[:].dtype, xx.dtype)

1315 assert_array_equal(eval(repr(xx), dict(array=np.array)), xx)

1316

1317 b = io.BytesIO()

1318 np.save(b, xx)

1319

1320 b.seek(0)

1321 yy = np.load(b)

1322 assert_equal(yy.itemsize, 0)

1323 assert_equal(xx, yy)

1324

1325 with temppath(suffix='.npy') as tmp:

1326 np.save(tmp, xx)

1327 yy = np.load(tmp)

1328 assert_equal(yy.itemsize, 0)

1329 assert_equal(xx, yy)

1330

1331 def test_base_attr(self):

1332 a = np.zeros(3, dtype='i4,f4')

1333 b = a[0]

1334 assert_(b.base is a)

1335

1336 def test_assignment(self):

1337 def testassign(arr, v):

1338 c = arr.copy()

1339 c[0] = v # assign using setitem

1340 c[1:] = v # assign using "dtype_transfer" code paths

1341 return c

1342

1343 dt = np.dtype([('foo', 'i8'), ('bar', 'i8')])

1344 arr = np.ones(2, dt)

1345 v1 = np.array([(2,3)], dtype=[('foo', 'i8'), ('bar', 'i8')])

1346 v2 = np.array([(2,3)], dtype=[('bar', 'i8'), ('foo', 'i8')])

1347 v3 = np.array([(2,3)], dtype=[('bar', 'i8'), ('baz', 'i8')])

1348 v4 = np.array([(2,)], dtype=[('bar', 'i8')])

1349 v5 = np.array([(2,3)], dtype=[('foo', 'f8'), ('bar', 'f8')])

1350 w = arr.view({'names': ['bar'], 'formats': ['i8'], 'offsets': [8]})

1351

1352 ans = np.array([(2,3),(2,3)], dtype=dt)

1353 assert_equal(testassign(arr, v1), ans)

1354 assert_equal(testassign(arr, v2), ans)

1355 assert_equal(testassign(arr, v3), ans)

1356 assert_raises(ValueError, lambda: testassign(arr, v4))

1357 assert_equal(testassign(arr, v5), ans)

1358 w[:] = 4

1359 assert_equal(arr, np.array([(1,4),(1,4)], dtype=dt))

1360

1361 # test field-reordering, assignment by position, and self-assignment

1362 a = np.array([(1,2,3)],

1363 dtype=[('foo', 'i8'), ('bar', 'i8'), ('baz', 'f4')])

1364 a[['foo', 'bar']] = a[['bar', 'foo']]

1365 assert_equal(a[0].item(), (2,1,3))

1366

1367 # test that this works even for 'simple_unaligned' structs

1368 # (ie, that PyArray_EquivTypes cares about field order too)

1369 a = np.array([(1,2)], dtype=[('a', 'i4'), ('b', 'i4')])

1370 a[['a', 'b']] = a[['b', 'a']]

1371 assert_equal(a[0].item(), (2,1))

1372

1373 def test_scalar_assignment(self):

1374 with assert_raises(ValueError):

1375 arr = np.arange(25).reshape(5, 5)

1376 arr.itemset(3)

1377

1378 def test_structuredscalar_indexing(self):

1379 # test gh-7262

1380 x = np.empty(shape=1, dtype="(2)3S,(2)3U")

1381 assert_equal(x[["f0","f1"]][0], x[0][["f0","f1"]])

1382 assert_equal(x[0], x[0][()])

1383

1384 def test_multiindex_titles(self):

1385 a = np.zeros(4, dtype=[(('a', 'b'), 'i'), ('c', 'i'), ('d', 'i')])

1386 assert_raises(KeyError, lambda : a[['a','c']])

1387 assert_raises(KeyError, lambda : a[['a','a']])

1388 assert_raises(ValueError, lambda : a[['b','b']]) # field exists, but repeated

1389 a[['b','c']] # no exception

1390

1391

1392class TestBool:

1393 def test_test_interning(self):

1394 a0 = np.bool_(0)

1395 b0 = np.bool_(False)

1396 assert_(a0 is b0)

1397 a1 = np.bool_(1)

1398 b1 = np.bool_(True)

1399 assert_(a1 is b1)

1400 assert_(np.array([True])[0] is a1)

1401 assert_(np.array(True)[()] is a1)

1402

1403 def test_sum(self):

1404 d = np.ones(101, dtype=bool)

1405 assert_equal(d.sum(), d.size)

1406 assert_equal(d[::2].sum(), d[::2].size)

1407 assert_equal(d[::-2].sum(), d[::-2].size)

1408

1409 d = np.frombuffer(b'\xff\xff' * 100, dtype=bool)

1410 assert_equal(d.sum(), d.size)

1411 assert_equal(d[::2].sum(), d[::2].size)

1412 assert_equal(d[::-2].sum(), d[::-2].size)

1413

1414 def check_count_nonzero(self, power, length):

1415 powers = [2 ** i for i in range(length)]

1416 for i in range(2**power):

1417 l = [(i & x) != 0 for x in powers]

1418 a = np.array(l, dtype=bool)

1419 c = builtins.sum(l)

1420 assert_equal(np.count_nonzero(a), c)

1421 av = a.view(np.uint8)

1422 av *= 3

1423 assert_equal(np.count_nonzero(a), c)

1424 av *= 4

1425 assert_equal(np.count_nonzero(a), c)

1426 av[av != 0] = 0xFF

1427 assert_equal(np.count_nonzero(a), c)

1428

1429 def test_count_nonzero(self):

1430 # check all 12 bit combinations in a length 17 array

1431 # covers most cases of the 16 byte unrolled code

1432 self.check_count_nonzero(12, 17)

1433

1434 @pytest.mark.slow

1435 def test_count_nonzero_all(self):

1436 # check all combinations in a length 17 array

1437 # covers all cases of the 16 byte unrolled code

1438 self.check_count_nonzero(17, 17)

1439

1440 def test_count_nonzero_unaligned(self):

1441 # prevent mistakes as e.g. gh-4060

1442 for o in range(7):

1443 a = np.zeros((18,), dtype=bool)[o+1:]

1444 a[:o] = True

1445 assert_equal(np.count_nonzero(a), builtins.sum(a.tolist()))

1446 a = np.ones((18,), dtype=bool)[o+1:]

1447 a[:o] = False

1448 assert_equal(np.count_nonzero(a), builtins.sum(a.tolist()))

1449

1450 def _test_cast_from_flexible(self, dtype):

1451 # empty string -> false

1452 for n in range(3):

1453 v = np.array(b'', (dtype, n))

1454 assert_equal(bool(v), False)

1455 assert_equal(bool(v[()]), False)

1456 assert_equal(v.astype(bool), False)

1457 assert_(isinstance(v.astype(bool), np.ndarray))

1458 assert_(v[()].astype(bool) is np.False_)

1459

1460 # anything else -> true

1461 for n in range(1, 4):

1462 for val in [b'a', b'0', b' ']:

1463 v = np.array(val, (dtype, n))

1464 assert_equal(bool(v), True)

1465 assert_equal(bool(v[()]), True)

1466 assert_equal(v.astype(bool), True)

1467 assert_(isinstance(v.astype(bool), np.ndarray))

1468 assert_(v[()].astype(bool) is np.True_)

1469

1470 def test_cast_from_void(self):

1471 self._test_cast_from_flexible(np.void)

1472

1473 @pytest.mark.xfail(reason="See gh-9847")

1474 def test_cast_from_unicode(self):

1475 self._test_cast_from_flexible(np.unicode_)

1476

1477 @pytest.mark.xfail(reason="See gh-9847")

1478 def test_cast_from_bytes(self):

1479 self._test_cast_from_flexible(np.bytes_)

1480

1481

1482class TestZeroSizeFlexible:

1483 @staticmethod

1484 def _zeros(shape, dtype=str):

1485 dtype = np.dtype(dtype)

1486 if dtype == np.void:

1487 return np.zeros(shape, dtype=(dtype, 0))

1488

1489 # not constructable directly

1490 dtype = np.dtype([('x', dtype, 0)])

1491 return np.zeros(shape, dtype=dtype)['x']

1492

1493 def test_create(self):

1494 zs = self._zeros(10, bytes)

1495 assert_equal(zs.itemsize, 0)

1496 zs = self._zeros(10, np.void)

1497 assert_equal(zs.itemsize, 0)

1498 zs = self._zeros(10, str)

1499 assert_equal(zs.itemsize, 0)

1500

1501 def _test_sort_partition(self, name, kinds, **kwargs):

1502 # Previously, these would all hang

1503 for dt in [bytes, np.void, str]:

1504 zs = self._zeros(10, dt)

1505 sort_method = getattr(zs, name)

1506 sort_func = getattr(np, name)

1507 for kind in kinds:

1508 sort_method(kind=kind, **kwargs)

1509 sort_func(zs, kind=kind, **kwargs)

1510

1511 def test_sort(self):

1512 self._test_sort_partition('sort', kinds='qhs')

1513

1514 def test_argsort(self):

1515 self._test_sort_partition('argsort', kinds='qhs')

1516

1517 def test_partition(self):

1518 self._test_sort_partition('partition', kinds=['introselect'], kth=2)

1519

1520 def test_argpartition(self):

1521 self._test_sort_partition('argpartition', kinds=['introselect'], kth=2)

1522

1523 def test_resize(self):

1524 # previously an error

1525 for dt in [bytes, np.void, str]:

1526 zs = self._zeros(10, dt)

1527 zs.resize(25)

1528 zs.resize((10, 10))

1529

1530 def test_view(self):

1531 for dt in [bytes, np.void, str]:

1532 zs = self._zeros(10, dt)

1533

1534 # viewing as itself should be allowed

1535 assert_equal(zs.view(dt).dtype, np.dtype(dt))

1536

1537 # viewing as any non-empty type gives an empty result

1538 assert_equal(zs.view((dt, 1)).shape, (0,))

1539

1540 def test_dumps(self):

1541 zs = self._zeros(10, int)

1542 assert_equal(zs, pickle.loads(zs.dumps()))

1543

1544 def test_pickle(self):

1545 for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):

1546 for dt in [bytes, np.void, str]:

1547 zs = self._zeros(10, dt)

1548 p = pickle.dumps(zs, protocol=proto)

1549 zs2 = pickle.loads(p)

1550

1551 assert_equal(zs.dtype, zs2.dtype)

1552

1553 @pytest.mark.skipif(pickle.HIGHEST_PROTOCOL < 5,

1554 reason="requires pickle protocol 5")

1555 def test_pickle_with_buffercallback(self):

1556 array = np.arange(10)

1557 buffers = []

1558 bytes_string = pickle.dumps(array, buffer_callback=buffers.append,

1559 protocol=5)

1560 array_from_buffer = pickle.loads(bytes_string, buffers=buffers)

1561 # when using pickle protocol 5 with buffer callbacks,

1562 # array_from_buffer is reconstructed from a buffer holding a view

1563 # to the initial array's data, so modifying an element in array

1564 # should modify it in array_from_buffer too.

1565 array[0] = -1

1566 assert array_from_buffer[0] == -1, array_from_buffer[0]

1567

1568

1569class TestMethods:

1570

1571 sort_kinds = ['quicksort', 'heapsort', 'stable']

1572

1573 def test_compress(self):

1574 tgt = [[5, 6, 7, 8, 9]]

1575 arr = np.arange(10).reshape(2, 5)

1576 out = arr.compress([0, 1], axis=0)

1577 assert_equal(out, tgt)

1578

1579 tgt = [[1, 3], [6, 8]]

1580 out = arr.compress([0, 1, 0, 1, 0], axis=1)

1581 assert_equal(out, tgt)

1582

1583 tgt = [[1], [6]]

1584 arr = np.arange(10).reshape(2, 5)

1585 out = arr.compress([0, 1], axis=1)

1586 assert_equal(out, tgt)

1587

1588 arr = np.arange(10).reshape(2, 5)

1589 out = arr.compress([0, 1])

1590 assert_equal(out, 1)

1591

1592 def test_choose(self):

1593 x = 2*np.ones((3,), dtype=int)

1594 y = 3*np.ones((3,), dtype=int)

1595 x2 = 2*np.ones((2, 3), dtype=int)

1596 y2 = 3*np.ones((2, 3), dtype=int)

1597 ind = np.array([0, 0, 1])

1598

1599 A = ind.choose((x, y))

1600 assert_equal(A, [2, 2, 3])

1601

1602 A = ind.choose((x2, y2))

1603 assert_equal(A, [[2, 2, 3], [2, 2, 3]])

1604

1605 A = ind.choose((x, y2))

1606 assert_equal(A, [[2, 2, 3], [2, 2, 3]])

1607

1608 oned = np.ones(1)

1609 # gh-12031, caused SEGFAULT

1610 assert_raises(TypeError, oned.choose,np.void(0), [oned])

1611

1612 # gh-6272 check overlap on out

1613 x = np.arange(5)

1614 y = np.choose([0,0,0], [x[:3], x[:3], x[:3]], out=x[1:4], mode='wrap')

1615 assert_equal(y, np.array([0, 1, 2]))

1616

1617 def test_prod(self):

1618 ba = [1, 2, 10, 11, 6, 5, 4]

1619 ba2 = [[1, 2, 3, 4], [5, 6, 7, 9], [10, 3, 4, 5]]

1620

1621 for ctype in [np.int16, np.uint16, np.int32, np.uint32,

1622 np.float32, np.float64, np.complex64, np.complex128]:

1623 a = np.array(ba, ctype)

1624 a2 = np.array(ba2, ctype)

1625 if ctype in ['1', 'b']:

1626 assert_raises(ArithmeticError, a.prod)

1627 assert_raises(ArithmeticError, a2.prod, axis=1)

1628 else:

1629 assert_equal(a.prod(axis=0), 26400)

1630 assert_array_equal(a2.prod(axis=0),

1631 np.array([50, 36, 84, 180], ctype))

1632 assert_array_equal(a2.prod(axis=-1),

1633 np.array([24, 1890, 600], ctype))

1634

1635 def test_repeat(self):

1636 m = np.array([1, 2, 3, 4, 5, 6])

1637 m_rect = m.reshape((2, 3))

1638

1639 A = m.repeat([1, 3, 2, 1, 1, 2])

1640 assert_equal(A, [1, 2, 2, 2, 3,

1641 3, 4, 5, 6, 6])

1642

1643 A = m.repeat(2)

1644 assert_equal(A, [1, 1, 2, 2, 3, 3,

1645 4, 4, 5, 5, 6, 6])

1646

1647 A = m_rect.repeat([2, 1], axis=0)

1648 assert_equal(A, [[1, 2, 3],

1649 [1, 2, 3],

1650 [4, 5, 6]])

1651

1652 A = m_rect.repeat([1, 3, 2], axis=1)

1653 assert_equal(A, [[1, 2, 2, 2, 3, 3],

1654 [4, 5, 5, 5, 6, 6]])

1655

1656 A = m_rect.repeat(2, axis=0)

1657 assert_equal(A, [[1, 2, 3],

1658 [1, 2, 3],

1659 [4, 5, 6],

1660 [4, 5, 6]])

1661

1662 A = m_rect.repeat(2, axis=1)

1663 assert_equal(A, [[1, 1, 2, 2, 3, 3],

1664 [4, 4, 5, 5, 6, 6]])

1665

1666 def test_reshape(self):

1667 arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])

1668

1669 tgt = [[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]]

1670 assert_equal(arr.reshape(2, 6), tgt)

1671

1672 tgt = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

1673 assert_equal(arr.reshape(3, 4), tgt)

1674

1675 tgt = [[1, 10, 8, 6], [4, 2, 11, 9], [7, 5, 3, 12]]

1676 assert_equal(arr.reshape((3, 4), order='F'), tgt)

1677

1678 tgt = [[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]]

1679 assert_equal(arr.T.reshape((3, 4), order='C'), tgt)

1680

1681 def test_round(self):

1682 def check_round(arr, expected, *round_args):

1683 assert_equal(arr.round(*round_args), expected)

1684 # With output array

1685 out = np.zeros_like(arr)

1686 res = arr.round(*round_args, out=out)

1687 assert_equal(out, expected)

1688 assert_equal(out, res)

1689

1690 check_round(np.array([1.2, 1.5]), [1, 2])

1691 check_round(np.array(1.5), 2)

1692 check_round(np.array([12.2, 15.5]), [10, 20], -1)

1693 check_round(np.array([12.15, 15.51]), [12.2, 15.5], 1)

1694 # Complex rounding

1695 check_round(np.array([4.5 + 1.5j]), [4 + 2j])

1696 check_round(np.array([12.5 + 15.5j]), [10 + 20j], -1)

1697

1698 def test_squeeze(self):

1699 a = np.array([[[1], [2], [3]]])

1700 assert_equal(a.squeeze(), [1, 2, 3])

1701 assert_equal(a.squeeze(axis=(0,)), [[1], [2], [3]])

1702 assert_raises(ValueError, a.squeeze, axis=(1,))

1703 assert_equal(a.squeeze(axis=(2,)), [[1, 2, 3]])

1704

1705 def test_transpose(self):

1706 a = np.array([[1, 2], [3, 4]])

1707 assert_equal(a.transpose(), [[1, 3], [2, 4]])

1708 assert_raises(ValueError, lambda: a.transpose(0))

1709 assert_raises(ValueError, lambda: a.transpose(0, 0))

1710 assert_raises(ValueError, lambda: a.transpose(0, 1, 2))

1711

1712 def test_sort(self):

1713 # test ordering for floats and complex containing nans. It is only

1714 # necessary to check the less-than comparison, so sorts that

1715 # only follow the insertion sort path are sufficient. We only

1716 # test doubles and complex doubles as the logic is the same.

1717

1718 # check doubles

1719 msg = "Test real sort order with nans"

1720 a = np.array([np.nan, 1, 0])

1721 b = np.sort(a)

1722 assert_equal(b, a[::-1], msg)

1723 # check complex

1724 msg = "Test complex sort order with nans"

1725 a = np.zeros(9, dtype=np.complex128)

1726 a.real += [np.nan, np.nan, np.nan, 1, 0, 1, 1, 0, 0]

1727 a.imag += [np.nan, 1, 0, np.nan, np.nan, 1, 0, 1, 0]

1728 b = np.sort(a)

1729 assert_equal(b, a[::-1], msg)

1730

1731 # all c scalar sorts use the same code with different types

1732 # so it suffices to run a quick check with one type. The number

1733 # of sorted items must be greater than ~50 to check the actual

1734 # algorithm because quick and merge sort fall over to insertion

1735 # sort for small arrays.

1736

1737 @pytest.mark.parametrize('dtype', [np.uint8, np.uint16, np.uint32, np.uint64,

1738 np.float16, np.float32, np.float64,

1739 np.longdouble])

1740 def test_sort_unsigned(self, dtype):

1741 a = np.arange(101, dtype=dtype)

1742 b = a[::-1].copy()

1743 for kind in self.sort_kinds:

1744 msg = "scalar sort, kind=%s" % kind

1745 c = a.copy()

1746 c.sort(kind=kind)

1747 assert_equal(c, a, msg)

1748 c = b.copy()

1749 c.sort(kind=kind)

1750 assert_equal(c, a, msg)

1751

1752 @pytest.mark.parametrize('dtype',

1753 [np.int8, np.int16, np.int32, np.int64, np.float16,

1754 np.float32, np.float64, np.longdouble])

1755 def test_sort_signed(self, dtype):

1756 a = np.arange(-50, 51, dtype=dtype)

1757 b = a[::-1].copy()

1758 for kind in self.sort_kinds:

1759 msg = "scalar sort, kind=%s" % (kind)

1760 c = a.copy()

1761 c.sort(kind=kind)

1762 assert_equal(c, a, msg)

1763 c = b.copy()

1764 c.sort(kind=kind)

1765 assert_equal(c, a, msg)

1766

1767 @pytest.mark.parametrize('dtype', [np.float32, np.float64, np.longdouble])

1768 @pytest.mark.parametrize('part', ['real', 'imag'])

1769 def test_sort_complex(self, part, dtype):

1770 # test complex sorts. These use the same code as the scalars

1771 # but the compare function differs.

1772 cdtype = {

1773 np.single: np.csingle,

1774 np.double: np.cdouble,

1775 np.longdouble: np.clongdouble,

1776 }[dtype]

1777 a = np.arange(-50, 51, dtype=dtype)

1778 b = a[::-1].copy()

1779 ai = (a * (1+1j)).astype(cdtype)

1780 bi = (b * (1+1j)).astype(cdtype)

1781 setattr(ai, part, 1)

1782 setattr(bi, part, 1)

1783 for kind in self.sort_kinds:

1784 msg = "complex sort, %s part == 1, kind=%s" % (part, kind)

1785 c = ai.copy()

1786 c.sort(kind=kind)

1787 assert_equal(c, ai, msg)

1788 c = bi.copy()

1789 c.sort(kind=kind)

1790 assert_equal(c, ai, msg)

1791

1792 def test_sort_complex_byte_swapping(self):

1793 # test sorting of complex arrays requiring byte-swapping, gh-5441

1794 for endianness in '<>':

1795 for dt in np.typecodes['Complex']:

1796 arr = np.array([1+3.j, 2+2.j, 3+1.j], dtype=endianness + dt)

1797 c = arr.copy()

1798 c.sort()

1799 msg = 'byte-swapped complex sort, dtype={0}'.format(dt)

1800 assert_equal(c, arr, msg)

1801

1802 @pytest.mark.parametrize('dtype', [np.bytes_, np.unicode_])

1803 def test_sort_string(self, dtype):

1804 # np.array will perform the encoding to bytes for us in the bytes test

1805 a = np.array(['aaaaaaaa' + chr(i) for i in range(101)], dtype=dtype)

1806 b = a[::-1].copy()

1807 for kind in self.sort_kinds:

1808 msg = "kind=%s" % kind

1809 c = a.copy()

1810 c.sort(kind=kind)

1811 assert_equal(c, a, msg)

1812 c = b.copy()

1813 c.sort(kind=kind)

1814 assert_equal(c, a, msg)

1815

1816 def test_sort_object(self):

1817 # test object array sorts.

1818 a = np.empty((101,), dtype=object)

1819 a[:] = list(range(101))

1820 b = a[::-1]

1821 for kind in ['q', 'h', 'm']:

1822 msg = "kind=%s" % kind

1823 c = a.copy()

1824 c.sort(kind=kind)

1825 assert_equal(c, a, msg)

1826 c = b.copy()

1827 c.sort(kind=kind)

1828 assert_equal(c, a, msg)

1829

1830 def test_sort_structured(self):

1831 # test record array sorts.

1832 dt = np.dtype([('f', float), ('i', int)])

1833 a = np.array([(i, i) for i in range(101)], dtype=dt)

1834 b = a[::-1]

1835 for kind in ['q', 'h', 'm']:

1836 msg = "kind=%s" % kind

1837 c = a.copy()

1838 c.sort(kind=kind)

1839 assert_equal(c, a, msg)

1840 c = b.copy()

1841 c.sort(kind=kind)

1842 assert_equal(c, a, msg)

1843

1844 @pytest.mark.parametrize('dtype', ['datetime64[D]', 'timedelta64[D]'])

1845 def test_sort_time(self, dtype):

1846 # test datetime64 and timedelta64 sorts.

1847 a = np.arange(0, 101, dtype=dtype)

1848 b = a[::-1]

1849 for kind in ['q', 'h', 'm']:

1850 msg = "kind=%s" % kind

1851 c = a.copy()

1852 c.sort(kind=kind)

1853 assert_equal(c, a, msg)

1854 c = b.copy()

1855 c.sort(kind=kind)

1856 assert_equal(c, a, msg)

1857

1858 def test_sort_axis(self):

1859 # check axis handling. This should be the same for all type

1860 # specific sorts, so we only check it for one type and one kind

1861 a = np.array([[3, 2], [1, 0]])

1862 b = np.array([[1, 0], [3, 2]])

1863 c = np.array([[2, 3], [0, 1]])

1864 d = a.copy()

1865 d.sort(axis=0)

1866 assert_equal(d, b, "test sort with axis=0")

1867 d = a.copy()

1868 d.sort(axis=1)

1869 assert_equal(d, c, "test sort with axis=1")

1870 d = a.copy()

1871 d.sort()

1872 assert_equal(d, c, "test sort with default axis")

1873

1874 def test_sort_size_0(self):

1875 # check axis handling for multidimensional empty arrays

1876 a = np.array([])

1877 a.shape = (3, 2, 1, 0)

1878 for axis in range(-a.ndim, a.ndim):

1879 msg = 'test empty array sort with axis={0}'.format(axis)

1880 assert_equal(np.sort(a, axis=axis), a, msg)

1881 msg = 'test empty array sort with axis=None'

1882 assert_equal(np.sort(a, axis=None), a.ravel(), msg)

1883

1884 def test_sort_bad_ordering(self):

1885 # test generic class with bogus ordering,

1886 # should not segfault.

1887 class Boom:

1888 def __lt__(self, other):

1889 return True

1890

1891 a = np.array([Boom()] * 100, dtype=object)

1892 for kind in self.sort_kinds:

1893 msg = "kind=%s" % kind

1894 c = a.copy()

1895 c.sort(kind=kind)

1896 assert_equal(c, a, msg)

1897

1898 def test_void_sort(self):

1899 # gh-8210 - previously segfaulted

1900 for i in range(4):

1901 rand = np.random.randint(256, size=4000, dtype=np.uint8)

1902 arr = rand.view('V4')

1903 arr[::-1].sort()

1904

1905 dt = np.dtype([('val', 'i4', (1,))])

1906 for i in range(4):

1907 rand = np.random.randint(256, size=4000, dtype=np.uint8)

1908 arr = rand.view(dt)

1909 arr[::-1].sort()

1910

1911 def test_sort_raises(self):

1912 #gh-9404

1913 arr = np.array([0, datetime.now(), 1], dtype=object)

1914 for kind in self.sort_kinds:

1915 assert_raises(TypeError, arr.sort, kind=kind)

1916 #gh-3879

1917 class Raiser:

1918 def raises_anything(*args, **kwargs):

1919 raise TypeError("SOMETHING ERRORED")

1920 __eq__ = __ne__ = __lt__ = __gt__ = __ge__ = __le__ = raises_anything

1921 arr = np.array([[Raiser(), n] for n in range(10)]).reshape(-1)

1922 np.random.shuffle(arr)

1923 for kind in self.sort_kinds:

1924 assert_raises(TypeError, arr.sort, kind=kind)

1925

1926 def test_sort_degraded(self):

1927 # test degraded dataset would take minutes to run with normal qsort

1928 d = np.arange(1000000)

1929 do = d.copy()

1930 x = d

1931 # create a median of 3 killer where each median is the sorted second

1932 # last element of the quicksort partition

1933 while x.size > 3:

1934 mid = x.size // 2

1935 x[mid], x[-2] = x[-2], x[mid]

1936 x = x[:-2]

1937

1938 assert_equal(np.sort(d), do)

1939 assert_equal(d[np.argsort(d)], do)

1940

1941 def test_copy(self):

1942 def assert_fortran(arr):

1943 assert_(arr.flags.fortran)

1944 assert_(arr.flags.f_contiguous)

1945 assert_(not arr.flags.c_contiguous)

1946

1947 def assert_c(arr):

1948 assert_(not arr.flags.fortran)

1949 assert_(not arr.flags.f_contiguous)

1950 assert_(arr.flags.c_contiguous)

1951

1952 a = np.empty((2, 2), order='F')

1953 # Test copying a Fortran array

1954 assert_c(a.copy())

1955 assert_c(a.copy('C'))

1956 assert_fortran(a.copy('F'))

1957 assert_fortran(a.copy('A'))

1958

1959 # Now test starting with a C array.

1960 a = np.empty((2, 2), order='C')

1961 assert_c(a.copy())

1962 assert_c(a.copy('C'))

1963 assert_fortran(a.copy('F'))

1964 assert_c(a.copy('A'))

1965

1966 def test_sort_order(self):

1967 # Test sorting an array with fields

1968 x1 = np.array([21, 32, 14])

1969 x2 = np.array(['my', 'first', 'name'])

1970 x3 = np.array([3.1, 4.5, 6.2])

1971 r = np.rec.fromarrays([x1, x2, x3], names='id,word,number')

1972

1973 r.sort(order=['id'])

1974 assert_equal(r.id, np.array([14, 21, 32]))

1975 assert_equal(r.word, np.array(['name', 'my', 'first']))

1976 assert_equal(r.number, np.array([6.2, 3.1, 4.5]))

1977

1978 r.sort(order=['word'])

1979 assert_equal(r.id, np.array([32, 21, 14]))

1980 assert_equal(r.word, np.array(['first', 'my', 'name']))

1981 assert_equal(r.number, np.array([4.5, 3.1, 6.2]))

1982

1983 r.sort(order=['number'])

1984 assert_equal(r.id, np.array([21, 32, 14]))

1985 assert_equal(r.word, np.array(['my', 'first', 'name']))

1986 assert_equal(r.number, np.array([3.1, 4.5, 6.2]))

1987

1988 assert_raises_regex(ValueError, 'duplicate',

1989 lambda: r.sort(order=['id', 'id']))

1990

1991 if sys.byteorder == 'little':

1992 strtype = '>i2'

1993 else:

1994 strtype = '<i2'

1995 mydtype = [('name', strchar + '5'), ('col2', strtype)]

1996 r = np.array([('a', 1), ('b', 255), ('c', 3), ('d', 258)],

1997 dtype=mydtype)

1998 r.sort(order='col2')

1999 assert_equal(r['col2'], [1, 3, 255, 258])

2000 assert_equal(r, np.array([('a', 1), ('c', 3), ('b', 255), ('d', 258)],

2001 dtype=mydtype))

2002

2003 def test_argsort(self):

2004 # all c scalar argsorts use the same code with different types

2005 # so it suffices to run a quick check with one type. The number

2006 # of sorted items must be greater than ~50 to check the actual

2007 # algorithm because quick and merge sort fall over to insertion

2008 # sort for small arrays.

2009

2010 for dtype in [np.int32, np.uint32, np.float32]:

2011 a = np.arange(101, dtype=dtype)

2012 b = a[::-1].copy()

2013 for kind in self.sort_kinds:

2014 msg = "scalar argsort, kind=%s, dtype=%s" % (kind, dtype)

2015 assert_equal(a.copy().argsort(kind=kind), a, msg)

2016 assert_equal(b.copy().argsort(kind=kind), b, msg)

2017

2018 # test complex argsorts. These use the same code as the scalars

2019 # but the compare function differs.

2020 ai = a*1j + 1

2021 bi = b*1j + 1

2022 for kind in self.sort_kinds:

2023 msg = "complex argsort, kind=%s" % kind

2024 assert_equal(ai.copy().argsort(kind=kind), a, msg)

2025 assert_equal(bi.copy().argsort(kind=kind), b, msg)

2026 ai = a + 1j

2027 bi = b + 1j

2028 for kind in self.sort_kinds:

2029 msg = "complex argsort, kind=%s" % kind

2030 assert_equal(ai.copy().argsort(kind=kind), a, msg)

2031 assert_equal(bi.copy().argsort(kind=kind), b, msg)

2032

2033 # test argsort of complex arrays requiring byte-swapping, gh-5441

2034 for endianness in '<>':

2035 for dt in np.typecodes['Complex']:

2036 arr = np.array([1+3.j, 2+2.j, 3+1.j], dtype=endianness + dt)

2037 msg = 'byte-swapped complex argsort, dtype={0}'.format(dt)

2038 assert_equal(arr.argsort(),

2039 np.arange(len(arr), dtype=np.intp), msg)

2040

2041 # test string argsorts.

2042 s = 'aaaaaaaa'

2043 a = np.array([s + chr(i) for i in range(101)])

2044 b = a[::-1].copy()

2045 r = np.arange(101)

2046 rr = r[::-1]

2047 for kind in self.sort_kinds:

2048 msg = "string argsort, kind=%s" % kind

2049 assert_equal(a.copy().argsort(kind=kind), r, msg)

2050 assert_equal(b.copy().argsort(kind=kind), rr, msg)

2051

2052 # test unicode argsorts.

2053 s = 'aaaaaaaa'

2054 a = np.array([s + chr(i) for i in range(101)], dtype=np.unicode_)

2055 b = a[::-1]

2056 r = np.arange(101)

2057 rr = r[::-1]

2058 for kind in self.sort_kinds:

2059 msg = "unicode argsort, kind=%s" % kind

2060 assert_equal(a.copy().argsort(kind=kind), r, msg)

2061 assert_equal(b.copy().argsort(kind=kind), rr, msg)

2062

2063 # test object array argsorts.

2064 a = np.empty((101,), dtype=object)

2065 a[:] = list(range(101))

2066 b = a[::-1]

2067 r = np.arange(101)

2068 rr = r[::-1]

2069 for kind in self.sort_kinds:

2070 msg = "object argsort, kind=%s" % kind

2071 assert_equal(a.copy().argsort(kind=kind), r, msg)

2072 assert_equal(b.copy().argsort(kind=kind), rr, msg)

2073

2074 # test structured array argsorts.

2075 dt = np.dtype([('f', float), ('i', int)])

2076 a = np.array([(i, i) for i in range(101)], dtype=dt)

2077 b = a[::-1]

2078 r = np.arange(101)

2079 rr = r[::-1]

2080 for kind in self.sort_kinds:

2081 msg = "structured array argsort, kind=%s" % kind

2082 assert_equal(a.copy().argsort(kind=kind), r, msg)

2083 assert_equal(b.copy().argsort(kind=kind), rr, msg)

2084

2085 # test datetime64 argsorts.

2086 a = np.arange(0, 101, dtype='datetime64[D]')

2087 b = a[::-1]

2088 r = np.arange(101)

2089 rr = r[::-1]

2090 for kind in ['q', 'h', 'm']:

2091 msg = "datetime64 argsort, kind=%s" % kind

2092 assert_equal(a.copy().argsort(kind=kind), r, msg)

2093 assert_equal(b.copy().argsort(kind=kind), rr, msg)

2094

2095 # test timedelta64 argsorts.

2096 a = np.arange(0, 101, dtype='timedelta64[D]')

2097 b = a[::-1]

2098 r = np.arange(101)

2099 rr = r[::-1]

2100 for kind in ['q', 'h', 'm']:

2101 msg = "timedelta64 argsort, kind=%s" % kind

2102 assert_equal(a.copy().argsort(kind=kind), r, msg)

2103 assert_equal(b.copy().argsort(kind=kind), rr, msg)

2104

2105 # check axis handling. This should be the same for all type

2106 # specific argsorts, so we only check it for one type and one kind

2107 a = np.array([[3, 2], [1, 0]])

2108 b = np.array([[1, 1], [0, 0]])

2109 c = np.array([[1, 0], [1, 0]])

2110 assert_equal(a.copy().argsort(axis=0), b)

2111 assert_equal(a.copy().argsort(axis=1), c)

2112 assert_equal(a.copy().argsort(), c)

2113

2114 # check axis handling for multidimensional empty arrays

2115 a = np.array([])

2116 a.shape = (3, 2, 1, 0)

2117 for axis in range(-a.ndim, a.ndim):

2118 msg = 'test empty array argsort with axis={0}'.format(axis)

2119 assert_equal(np.argsort(a, axis=axis),

2120 np.zeros_like(a, dtype=np.intp), msg)

2121 msg = 'test empty array argsort with axis=None'

2122 assert_equal(np.argsort(a, axis=None),

2123 np.zeros_like(a.ravel(), dtype=np.intp), msg)

2124

2125 # check that stable argsorts are stable

2126 r = np.arange(100)

2127 # scalars

2128 a = np.zeros(100)

2129 assert_equal(a.argsort(kind='m'), r)

2130 # complex

2131 a = np.zeros(100, dtype=complex)

2132 assert_equal(a.argsort(kind='m'), r)

2133 # string

2134 a = np.array(['aaaaaaaaa' for i in range(100)])

2135 assert_equal(a.argsort(kind='m'), r)

2136 # unicode

2137 a = np.array(['aaaaaaaaa' for i in range(100)], dtype=np.unicode_)

2138 assert_equal(a.argsort(kind='m'), r)

2139

2140 def test_sort_unicode_kind(self):

2141 d = np.arange(10)

2142 k = b'\xc3\xa4'.decode("UTF8")

2143 assert_raises(ValueError, d.sort, kind=k)

2144 assert_raises(ValueError, d.argsort, kind=k)

2145

2146 def test_searchsorted(self):

2147 # test for floats and complex containing nans. The logic is the

2148 # same for all float types so only test double types for now.

2149 # The search sorted routines use the compare functions for the

2150 # array type, so this checks if that is consistent with the sort

2151 # order.

2152

2153 # check double

2154 a = np.array([0, 1, np.nan])

2155 msg = "Test real searchsorted with nans, side='l'"

2156 b = a.searchsorted(a, side='l')

2157 assert_equal(b, np.arange(3), msg)

2158 msg = "Test real searchsorted with nans, side='r'"

2159 b = a.searchsorted(a, side='r')

2160 assert_equal(b, np.arange(1, 4), msg)

2161 # check keyword arguments

2162 a.searchsorted(v=1)

2163 # check double complex

2164 a = np.zeros(9, dtype=np.complex128)

2165 a.real += [0, 0, 1, 1, 0, 1, np.nan, np.nan, np.nan]

2166 a.imag += [0, 1, 0, 1, np.nan, np.nan, 0, 1, np.nan]

2167 msg = "Test complex searchsorted with nans, side='l'"

2168 b = a.searchsorted(a, side='l')

2169 assert_equal(b, np.arange(9), msg)

2170 msg = "Test complex searchsorted with nans, side='r'"

2171 b = a.searchsorted(a, side='r')

2172 assert_equal(b, np.arange(1, 10), msg)

2173 msg = "Test searchsorted with little endian, side='l'"

2174 a = np.array([0, 128], dtype='<i4')

2175 b = a.searchsorted(np.array(128, dtype='<i4'))

2176 assert_equal(b, 1, msg)

2177 msg = "Test searchsorted with big endian, side='l'"

2178 a = np.array([0, 128], dtype='>i4')

2179 b = a.searchsorted(np.array(128, dtype='>i4'))

2180 assert_equal(b, 1, msg)

2181

2182 # Check 0 elements

2183 a = np.ones(0)

2184 b = a.searchsorted([0, 1, 2], 'l')

2185 assert_equal(b, [0, 0, 0])

2186 b = a.searchsorted([0, 1, 2], 'r')

2187 assert_equal(b, [0, 0, 0])

2188 a = np.ones(1)

2189 # Check 1 element

2190 b = a.searchsorted([0, 1, 2], 'l')

2191 assert_equal(b, [0, 0, 1])

2192 b = a.searchsorted([0, 1, 2], 'r')

2193 assert_equal(b, [0, 1, 1])

2194 # Check all elements equal

2195 a = np.ones(2)

2196 b = a.searchsorted([0, 1, 2], 'l')

2197 assert_equal(b, [0, 0, 2])

2198 b = a.searchsorted([0, 1, 2], 'r')

2199 assert_equal(b, [0, 2, 2])

2200

2201 # Test searching unaligned array

2202 a = np.arange(10)

2203 aligned = np.empty(a.itemsize * a.size + 1, 'uint8')

2204 unaligned = aligned[1:].view(a.dtype)

2205 unaligned[:] = a

2206 # Test searching unaligned array

2207 b = unaligned.searchsorted(a, 'l')

2208 assert_equal(b, a)

2209 b = unaligned.searchsorted(a, 'r')

2210 assert_equal(b, a + 1)

2211 # Test searching for unaligned keys

2212 b = a.searchsorted(unaligned, 'l')

2213 assert_equal(b, a)

2214 b = a.searchsorted(unaligned, 'r')

2215 assert_equal(b, a + 1)

2216

2217 # Test smart resetting of binsearch indices

2218 a = np.arange(5)

2219 b = a.searchsorted([6, 5, 4], 'l')

2220 assert_equal(b, [5, 5, 4])

2221 b = a.searchsorted([6, 5, 4], 'r')

2222 assert_equal(b, [5, 5, 5])

2223

2224 # Test all type specific binary search functions

2225 types = ''.join((np.typecodes['AllInteger'], np.typecodes['AllFloat'],

2226 np.typecodes['Datetime'], '?O'))

2227 for dt in types:

2228 if dt == 'M':

2229 dt = 'M8[D]'

2230 if dt == '?':

2231 a = np.arange(2, dtype=dt)

2232 out = np.arange(2)

2233 else:

2234 a = np.arange(0, 5, dtype=dt)

2235 out = np.arange(5)

2236 b = a.searchsorted(a, 'l')

2237 assert_equal(b, out)

2238 b = a.searchsorted(a, 'r')

2239 assert_equal(b, out + 1)

2240 # Test empty array, use a fresh array to get warnings in

2241 # valgrind if access happens.

2242 e = np.ndarray(shape=0, buffer=b'', dtype=dt)

2243 b = e.searchsorted(a, 'l')

2244 assert_array_equal(b, np.zeros(len(a), dtype=np.intp))

2245 b = a.searchsorted(e, 'l')

2246 assert_array_equal(b, np.zeros(0, dtype=np.intp))

2247

2248 def test_searchsorted_unicode(self):

2249 # Test searchsorted on unicode strings.

2250

2251 # 1.6.1 contained a string length miscalculation in

2252 # arraytypes.c.src:UNICODE_compare() which manifested as

2253 # incorrect/inconsistent results from searchsorted.

2254 a = np.array(['P:\\20x_dapi_cy3\\20x_dapi_cy3_20100185_1',

2255 'P:\\20x_dapi_cy3\\20x_dapi_cy3_20100186_1',

2256 'P:\\20x_dapi_cy3\\20x_dapi_cy3_20100187_1',

2257 'P:\\20x_dapi_cy3\\20x_dapi_cy3_20100189_1',

2258 'P:\\20x_dapi_cy3\\20x_dapi_cy3_20100190_1',

2259 'P:\\20x_dapi_cy3\\20x_dapi_cy3_20100191_1',

2260 'P:\\20x_dapi_cy3\\20x_dapi_cy3_20100192_1',

2261 'P:\\20x_dapi_cy3\\20x_dapi_cy3_20100193_1',

2262 'P:\\20x_dapi_cy3\\20x_dapi_cy3_20100194_1',

2263 'P:\\20x_dapi_cy3\\20x_dapi_cy3_20100195_1',

2264 'P:\\20x_dapi_cy3\\20x_dapi_cy3_20100196_1',

2265 'P:\\20x_dapi_cy3\\20x_dapi_cy3_20100197_1',

2266 'P:\\20x_dapi_cy3\\20x_dapi_cy3_20100198_1',

2267 'P:\\20x_dapi_cy3\\20x_dapi_cy3_20100199_1'],

2268 dtype=np.unicode_)

2269 ind = np.arange(len(a))

2270 assert_equal([a.searchsorted(v, 'left') for v in a], ind)

2271 assert_equal([a.searchsorted(v, 'right') for v in a], ind + 1)

2272 assert_equal([a.searchsorted(a[i], 'left') for i in ind], ind)

2273 assert_equal([a.searchsorted(a[i], 'right') for i in ind], ind + 1)

2274

2275 def test_searchsorted_with_invalid_sorter(self):

2276 a = np.array([5, 2, 1, 3, 4])

2277 s = np.argsort(a)

2278 assert_raises(TypeError, np.searchsorted, a, 0,

2279 sorter=np.array((1, (2, 3)), dtype=object))

2280 assert_raises(TypeError, np.searchsorted, a, 0, sorter=[1.1])

2281 assert_raises(ValueError, np.searchsorted, a, 0, sorter=[1, 2, 3, 4])

2282 assert_raises(ValueError, np.searchsorted, a, 0, sorter=[1, 2, 3, 4, 5, 6])

2283

2284 # bounds check

2285 assert_raises(ValueError, np.searchsorted, a, 4, sorter=[0, 1, 2, 3, 5])

2286 assert_raises(ValueError, np.searchsorted, a, 0, sorter=[-1, 0, 1, 2, 3])

2287 assert_raises(ValueError, np.searchsorted, a, 0, sorter=[4, 0, -1, 2, 3])

2288

2289 def test_searchsorted_with_sorter(self):

2290 a = np.random.rand(300)

2291 s = a.argsort()

2292 b = np.sort(a)

2293 k = np.linspace(0, 1, 20)

2294 assert_equal(b.searchsorted(k), a.searchsorted(k, sorter=s))

2295

2296 a = np.array([0, 1, 2, 3, 5]*20)

2297 s = a.argsort()

2298 k = [0, 1, 2, 3, 5]

2299 expected = [0, 20, 40, 60, 80]

2300 assert_equal(a.searchsorted(k, side='l', sorter=s), expected)

2301 expected = [20, 40, 60, 80, 100]

2302 assert_equal(a.searchsorted(k, side='r', sorter=s), expected)

2303

2304 # Test searching unaligned array

2305 keys = np.arange(10)

2306 a = keys.copy()

2307 np.random.shuffle(s)

2308 s = a.argsort()

2309 aligned = np.empty(a.itemsize * a.size + 1, 'uint8')

2310 unaligned = aligned[1:].view(a.dtype)

2311 # Test searching unaligned array

2312 unaligned[:] = a

2313 b = unaligned.searchsorted(keys, 'l', s)

2314 assert_equal(b, keys)

2315 b = unaligned.searchsorted(keys, 'r', s)

2316 assert_equal(b, keys + 1)

2317 # Test searching for unaligned keys

2318 unaligned[:] = keys

2319 b = a.searchsorted(unaligned, 'l', s)

2320 assert_equal(b, keys)

2321 b = a.searchsorted(unaligned, 'r', s)

2322 assert_equal(b, keys + 1)

2323

2324 # Test all type specific indirect binary search functions

2325 types = ''.join((np.typecodes['AllInteger'], np.typecodes['AllFloat'],

2326 np.typecodes['Datetime'], '?O'))

2327 for dt in types:

2328 if dt == 'M':

2329 dt = 'M8[D]'

2330 if dt == '?':

2331 a = np.array([1, 0], dtype=dt)

2332 # We want the sorter array to be of a type that is different

2333 # from np.intp in all platforms, to check for #4698

2334 s = np.array([1, 0], dtype=np.int16)

2335 out = np.array([1, 0])

2336 else:

2337 a = np.array([3, 4, 1, 2, 0], dtype=dt)

2338 # We want the sorter array to be of a type that is different

2339 # from np.intp in all platforms, to check for #4698

2340 s = np.array([4, 2, 3, 0, 1], dtype=np.int16)

2341 out = np.array([3, 4, 1, 2, 0], dtype=np.intp)

2342 b = a.searchsorted(a, 'l', s)

2343 assert_equal(b, out)

2344 b = a.searchsorted(a, 'r', s)

2345 assert_equal(b, out + 1)

2346 # Test empty array, use a fresh array to get warnings in

2347 # valgrind if access happens.

2348 e = np.ndarray(shape=0, buffer=b'', dtype=dt)

2349 b = e.searchsorted(a, 'l', s[:0])

2350 assert_array_equal(b, np.zeros(len(a), dtype=np.intp))

2351 b = a.searchsorted(e, 'l', s)

2352 assert_array_equal(b, np.zeros(0, dtype=np.intp))

2353

2354 # Test non-contiguous sorter array

2355 a = np.array([3, 4, 1, 2, 0])

2356 srt = np.empty((10,), dtype=np.intp)

2357 srt[1::2] = -1

2358 srt[::2] = [4, 2, 3, 0, 1]

2359 s = srt[::2]

2360 out = np.array([3, 4, 1, 2, 0], dtype=np.intp)

2361 b = a.searchsorted(a, 'l', s)

2362 assert_equal(b, out)

2363 b = a.searchsorted(a, 'r', s)

2364 assert_equal(b, out + 1)

2365

2366 def test_searchsorted_return_type(self):

2367 # Functions returning indices should always return base ndarrays

2368 class A(np.ndarray):

2369 pass

2370 a = np.arange(5).view(A)

2371 b = np.arange(1, 3).view(A)

2372 s = np.arange(5).view(A)

2373 assert_(not isinstance(a.searchsorted(b, 'l'), A))

2374 assert_(not isinstance(a.searchsorted(b, 'r'), A))

2375 assert_(not isinstance(a.searchsorted(b, 'l', s), A))

2376 assert_(not isinstance(a.searchsorted(b, 'r', s), A))

2377

2378 def test_argpartition_out_of_range(self):

2379 # Test out of range values in kth raise an error, gh-5469

2380 d = np.arange(10)

2381 assert_raises(ValueError, d.argpartition, 10)

2382 assert_raises(ValueError, d.argpartition, -11)

2383 # Test also for generic type argpartition, which uses sorting

2384 # and used to not bound check kth

2385 d_obj = np.arange(10, dtype=object)

2386 assert_raises(ValueError, d_obj.argpartition, 10)

2387 assert_raises(ValueError, d_obj.argpartition, -11)

2388

2389 def test_partition_out_of_range(self):

2390 # Test out of range values in kth raise an error, gh-5469

2391 d = np.arange(10)

2392 assert_raises(ValueError, d.partition, 10)

2393 assert_raises(ValueError, d.partition, -11)

2394 # Test also for generic type partition, which uses sorting

2395 # and used to not bound check kth

2396 d_obj = np.arange(10, dtype=object)

2397 assert_raises(ValueError, d_obj.partition, 10)

2398 assert_raises(ValueError, d_obj.partition, -11)

2399

2400 def test_argpartition_integer(self):

2401 # Test non-integer values in kth raise an error/

2402 d = np.arange(10)

2403 assert_raises(TypeError, d.argpartition, 9.)

2404 # Test also for generic type argpartition, which uses sorting

2405 # and used to not bound check kth

2406 d_obj = np.arange(10, dtype=object)

2407 assert_raises(TypeError, d_obj.argpartition, 9.)

2408

2409 def test_partition_integer(self):

2410 # Test out of range values in kth raise an error, gh-5469

2411 d = np.arange(10)

2412 assert_raises(TypeError, d.partition, 9.)

2413 # Test also for generic type partition, which uses sorting

2414 # and used to not bound check kth

2415 d_obj = np.arange(10, dtype=object)

2416 assert_raises(TypeError, d_obj.partition, 9.)

2417

2418 def test_partition_empty_array(self):

2419 # check axis handling for multidimensional empty arrays

2420 a = np.array([])

2421 a.shape = (3, 2, 1, 0)

2422 for axis in range(-a.ndim, a.ndim):

2423 msg = 'test empty array partition with axis={0}'.format(axis)

2424 assert_equal(np.partition(a, 0, axis=axis), a, msg)

2425 msg = 'test empty array partition with axis=None'

2426 assert_equal(np.partition(a, 0, axis=None), a.ravel(), msg)

2427

2428 def test_argpartition_empty_array(self):

2429 # check axis handling for multidimensional empty arrays

2430 a = np.array([])

2431 a.shape = (3, 2, 1, 0)

2432 for axis in range(-a.ndim, a.ndim):

2433 msg = 'test empty array argpartition with axis={0}'.format(axis)

2434 assert_equal(np.partition(a, 0, axis=axis),

2435 np.zeros_like(a, dtype=np.intp), msg)

2436 msg = 'test empty array argpartition with axis=None'

2437 assert_equal(np.partition(a, 0, axis=None),

2438 np.zeros_like(a.ravel(), dtype=np.intp), msg)

2439

2440 def test_partition(self):

2441 d = np.arange(10)

2442 assert_raises(TypeError, np.partition, d, 2, kind=1)

2443 assert_raises(ValueError, np.partition, d, 2, kind="nonsense")

2444 assert_raises(ValueError, np.argpartition, d, 2, kind="nonsense")

2445 assert_raises(ValueError, d.partition, 2, axis=0, kind="nonsense")

2446 assert_raises(ValueError, d.argpartition, 2, axis=0, kind="nonsense")

2447 for k in ("introselect",):

2448 d = np.array([])

2449 assert_array_equal(np.partition(d, 0, kind=k), d)

2450 assert_array_equal(np.argpartition(d, 0, kind=k), d)

2451 d = np.ones(1)

2452 assert_array_equal(np.partition(d, 0, kind=k)[0], d)

2453 assert_array_equal(d[np.argpartition(d, 0, kind=k)],

2454 np.partition(d, 0, kind=k))

2455

2456 # kth not modified

2457 kth = np.array([30, 15, 5])

2458 okth = kth.copy()

2459 np.partition(np.arange(40), kth)

2460 assert_array_equal(kth, okth)

2461

2462 for r in ([2, 1], [1, 2], [1, 1]):

2463 d = np.array(r)

2464 tgt = np.sort(d)

2465 assert_array_equal(np.partition(d, 0, kind=k)[0], tgt[0])

2466 assert_array_equal(np.partition(d, 1, kind=k)[1], tgt[1])

2467 assert_array_equal(d[np.argpartition(d, 0, kind=k)],

2468 np.partition(d, 0, kind=k))

2469 assert_array_equal(d[np.argpartition(d, 1, kind=k)],

2470 np.partition(d, 1, kind=k))

2471 for i in range(d.size):

2472 d[i:].partition(0, kind=k)

2473 assert_array_equal(d, tgt)

2474

2475 for r in ([3, 2, 1], [1, 2, 3], [2, 1, 3], [2, 3, 1],

2476 [1, 1, 1], [1, 2, 2], [2, 2, 1], [1, 2, 1]):

2477 d = np.array(r)

2478 tgt = np.sort(d)

2479 assert_array_equal(np.partition(d, 0, kind=k)[0], tgt[0])

2480 assert_array_equal(np.partition(d, 1, kind=k)[1], tgt[1])

2481 assert_array_equal(np.partition(d, 2, kind=k)[2], tgt[2])

2482 assert_array_equal(d[np.argpartition(d, 0, kind=k)],

2483 np.partition(d, 0, kind=k))

2484 assert_array_equal(d[np.argpartition(d, 1, kind=k)],

2485 np.partition(d, 1, kind=k))

2486 assert_array_equal(d[np.argpartition(d, 2, kind=k)],

2487 np.partition(d, 2, kind=k))

2488 for i in range(d.size):

2489 d[i:].partition(0, kind=k)

2490 assert_array_equal(d, tgt)

2491

2492 d = np.ones(50)

2493 assert_array_equal(np.partition(d, 0, kind=k), d)

2494 assert_array_equal(d[np.argpartition(d, 0, kind=k)],

2495 np.partition(d, 0, kind=k))

2496

2497 # sorted

2498 d = np.arange(49)

2499 assert_equal(np.partition(d, 5, kind=k)[5], 5)

2500 assert_equal(np.partition(d, 15, kind=k)[15], 15)

2501 assert_array_equal(d[np.argpartition(d, 5, kind=k)],

2502 np.partition(d, 5, kind=k))

2503 assert_array_equal(d[np.argpartition(d, 15, kind=k)],

2504 np.partition(d, 15, kind=k))

2505

2506 # rsorted

2507 d = np.arange(47)[::-1]

2508 assert_equal(np.partition(d, 6, kind=k)[6], 6)

2509 assert_equal(np.partition(d, 16, kind=k)[16], 16)

2510 assert_array_equal(d[np.argpartition(d, 6, kind=k)],

2511 np.partition(d, 6, kind=k))

2512 assert_array_equal(d[np.argpartition(d, 16, kind=k)],

2513 np.partition(d, 16, kind=k))

2514

2515 assert_array_equal(np.partition(d, -6, kind=k),

2516 np.partition(d, 41, kind=k))

2517 assert_array_equal(np.partition(d, -16, kind=k),

2518 np.partition(d, 31, kind=k))

2519 assert_array_equal(d[np.argpartition(d, -6, kind=k)],

2520 np.partition(d, 41, kind=k))

2521

2522 # median of 3 killer, O(n^2) on pure median 3 pivot quickselect

2523 # exercises the median of median of 5 code used to keep O(n)

2524 d = np.arange(1000000)

2525 x = np.roll(d, d.size // 2)

2526 mid = x.size // 2 + 1

2527 assert_equal(np.partition(x, mid)[mid], mid)

2528 d = np.arange(1000001)

2529 x = np.roll(d, d.size // 2 + 1)

2530 mid = x.size // 2 + 1

2531 assert_equal(np.partition(x, mid)[mid], mid)

2532

2533 # max

2534 d = np.ones(10)

2535 d[1] = 4

2536 assert_equal(np.partition(d, (2, -1))[-1], 4)

2537 assert_equal(np.partition(d, (2, -1))[2], 1)

2538 assert_equal(d[np.argpartition(d, (2, -1))][-1], 4)

2539 assert_equal(d[np.argpartition(d, (2, -1))][2], 1)

2540 d[1] = np.nan

2541 assert_(np.isnan(d[np.argpartition(d, (2, -1))][-1]))

2542 assert_(np.isnan(np.partition(d, (2, -1))[-1]))

2543

2544 # equal elements

2545 d = np.arange(47) % 7

2546 tgt = np.sort(np.arange(47) % 7)

2547 np.random.shuffle(d)

2548 for i in range(d.size):

2549 assert_equal(np.partition(d, i, kind=k)[i], tgt[i])

2550 assert_array_equal(d[np.argpartition(d, 6, kind=k)],

2551 np.partition(d, 6, kind=k))

2552 assert_array_equal(d[np.argpartition(d, 16, kind=k)],

2553 np.partition(d, 16, kind=k))

2554 for i in range(d.size):

2555 d[i:].partition(0, kind=k)

2556 assert_array_equal(d, tgt)

2557

2558 d = np.array([0, 1, 2, 3, 4, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,

2559 7, 7, 7, 7, 7, 9])

2560 kth = [0, 3, 19, 20]

2561 assert_equal(np.partition(d, kth, kind=k)[kth], (0, 3, 7, 7))

2562 assert_equal(d[np.argpartition(d, kth, kind=k)][kth], (0, 3, 7, 7))

2563

2564 d = np.array([2, 1])

2565 d.partition(0, kind=k)

2566 assert_raises(ValueError, d.partition, 2)

2567 assert_raises(np.AxisError, d.partition, 3, axis=1)

2568 assert_raises(ValueError, np.partition, d, 2)

2569 assert_raises(np.AxisError, np.partition, d, 2, axis=1)

2570 assert_raises(ValueError, d.argpartition, 2)

2571 assert_raises(np.AxisError, d.argpartition, 3, axis=1)

2572 assert_raises(ValueError, np.argpartition, d, 2)

2573 assert_raises(np.AxisError, np.argpartition, d, 2, axis=1)

2574 d = np.arange(10).reshape((2, 5))

2575 d.partition(1, axis=0, kind=k)

2576 d.partition(4, axis=1, kind=k)

2577 np.partition(d, 1, axis=0, kind=k)

2578 np.partition(d, 4, axis=1, kind=k)

2579 np.partition(d, 1, axis=None, kind=k)

2580 np.partition(d, 9, axis=None, kind=k)

2581 d.argpartition(1, axis=0, kind=k)

2582 d.argpartition(4, axis=1, kind=k)

2583 np.argpartition(d, 1, axis=0, kind=k)

2584 np.argpartition(d, 4, axis=1, kind=k)

2585 np.argpartition(d, 1, axis=None, kind=k)

2586 np.argpartition(d, 9, axis=None, kind=k)

2587 assert_raises(ValueError, d.partition, 2, axis=0)

2588 assert_raises(ValueError, d.partition, 11, axis=1)

2589 assert_raises(TypeError, d.partition, 2, axis=None)

2590 assert_raises(ValueError, np.partition, d, 9, axis=1)

2591 assert_raises(ValueError, np.partition, d, 11, axis=None)

2592 assert_raises(ValueError, d.argpartition, 2, axis=0)

2593 assert_raises(ValueError, d.argpartition, 11, axis=1)

2594 assert_raises(ValueError, np.argpartition, d, 9, axis=1)

2595 assert_raises(ValueError, np.argpartition, d, 11, axis=None)

2596

2597 td = [(dt, s) for dt in [np.int32, np.float32, np.complex64]

2598 for s in (9, 16)]

2599 for dt, s in td:

2600 aae = assert_array_equal

2601 at = assert_

2602

2603 d = np.arange(s, dtype=dt)

2604 np.random.shuffle(d)

2605 d1 = np.tile(np.arange(s, dtype=dt), (4, 1))

2606 map(np.random.shuffle, d1)

2607 d0 = np.transpose(d1)

2608 for i in range(d.size):

2609 p = np.partition(d, i, kind=k)

2610 assert_equal(p[i], i)

2611 # all before are smaller

2612 assert_array_less(p[:i], p[i])

2613 # all after are larger

2614 assert_array_less(p[i], p[i + 1:])

2615 aae(p, d[np.argpartition(d, i, kind=k)])

2616

2617 p = np.partition(d1, i, axis=1, kind=k)

2618 aae(p[:, i], np.array([i] * d1.shape[0], dtype=dt))

2619 # array_less does not seem to work right

2620 at((p[:, :i].T <= p[:, i]).all(),

2621 msg="%d: %r <= %r" % (i, p[:, i], p[:, :i].T))

2622 at((p[:, i + 1:].T > p[:, i]).all(),

2623 msg="%d: %r < %r" % (i, p[:, i], p[:, i + 1:].T))

2624 aae(p, d1[np.arange(d1.shape[0])[:, None],

2625 np.argpartition(d1, i, axis=1, kind=k)])

2626

2627 p = np.partition(d0, i, axis=0, kind=k)

2628 aae(p[i, :], np.array([i] * d1.shape[0], dtype=dt))

2629 # array_less does not seem to work right

2630 at((p[:i, :] <= p[i, :]).all(),

2631 msg="%d: %r <= %r" % (i, p[i, :], p[:i, :]))

2632 at((p[i + 1:, :] > p[i, :]).all(),

2633 msg="%d: %r < %r" % (i, p[i, :], p[:, i + 1:]))

2634 aae(p, d0[np.argpartition(d0, i, axis=0, kind=k),

2635 np.arange(d0.shape[1])[None, :]])

2636

2637 # check inplace

2638 dc = d.copy()

2639 dc.partition(i, kind=k)

2640 assert_equal(dc, np.partition(d, i, kind=k))

2641 dc = d0.copy()

2642 dc.partition(i, axis=0, kind=k)

2643 assert_equal(dc, np.partition(d0, i, axis=0, kind=k))

2644 dc = d1.copy()

2645 dc.partition(i, axis=1, kind=k)

2646 assert_equal(dc, np.partition(d1, i, axis=1, kind=k))

2647

2648 def assert_partitioned(self, d, kth):

2649 prev = 0

2650 for k in np.sort(kth):

2651 assert_array_less(d[prev:k], d[k], err_msg='kth %d' % k)

2652 assert_((d[k:] >= d[k]).all(),

2653 msg="kth %d, %r not greater equal %d" % (k, d[k:], d[k]))

2654 prev = k + 1

2655

2656 def test_partition_iterative(self):

2657 d = np.arange(17)

2658 kth = (0, 1, 2, 429, 231)

2659 assert_raises(ValueError, d.partition, kth)

2660 assert_raises(ValueError, d.argpartition, kth)

2661 d = np.arange(10).reshape((2, 5))

2662 assert_raises(ValueError, d.partition, kth, axis=0)

2663 assert_raises(ValueError, d.partition, kth, axis=1)

2664 assert_raises(ValueError, np.partition, d, kth, axis=1)

2665 assert_raises(ValueError, np.partition, d, kth, axis=None)

2666

2667 d = np.array([3, 4, 2, 1])

2668 p = np.partition(d, (0, 3))

2669 self.assert_partitioned(p, (0, 3))

2670 self.assert_partitioned(d[np.argpartition(d, (0, 3))], (0, 3))

2671

2672 assert_array_equal(p, np.partition(d, (-3, -1)))

2673 assert_array_equal(p, d[np.argpartition(d, (-3, -1))])

2674

2675 d = np.arange(17)

2676 np.random.shuffle(d)

2677 d.partition(range(d.size))

2678 assert_array_equal(np.arange(17), d)

2679 np.random.shuffle(d)

2680 assert_array_equal(np.arange(17), d[d.argpartition(range(d.size))])

2681

2682 # test unsorted kth

2683 d = np.arange(17)

2684 np.random.shuffle(d)

2685 keys = np.array([1, 3, 8, -2])

2686 np.random.shuffle(d)

2687 p = np.partition(d, keys)

2688 self.assert_partitioned(p, keys)

2689 p = d[np.argpartition(d, keys)]

2690 self.assert_partitioned(p, keys)

2691 np.random.shuffle(keys)

2692 assert_array_equal(np.partition(d, keys), p)

2693 assert_array_equal(d[np.argpartition(d, keys)], p)

2694

2695 # equal kth

2696 d = np.arange(20)[::-1]

2697 self.assert_partitioned(np.partition(d, [5]*4), [5])

2698 self.assert_partitioned(np.partition(d, [5]*4 + [6, 13]),

2699 [5]*4 + [6, 13])

2700 self.assert_partitioned(d[np.argpartition(d, [5]*4)], [5])

2701 self.assert_partitioned(d[np.argpartition(d, [5]*4 + [6, 13])],

2702 [5]*4 + [6, 13])

2703

2704 d = np.arange(12)

2705 np.random.shuffle(d)

2706 d1 = np.tile(np.arange(12), (4, 1))

2707 map(np.random.shuffle, d1)

2708 d0 = np.transpose(d1)

2709

2710 kth = (1, 6, 7, -1)

2711 p = np.partition(d1, kth, axis=1)

2712 pa = d1[np.arange(d1.shape[0])[:, None],

2713 d1.argpartition(kth, axis=1)]

2714 assert_array_equal(p, pa)

2715 for i in range(d1.shape[0]):

2716 self.assert_partitioned(p[i,:], kth)

2717 p = np.partition(d0, kth, axis=0)

2718 pa = d0[np.argpartition(d0, kth, axis=0),

2719 np.arange(d0.shape[1])[None,:]]

2720 assert_array_equal(p, pa)

2721 for i in range(d0.shape[1]):

2722 self.assert_partitioned(p[:, i], kth)

2723

2724 def test_partition_cdtype(self):

2725 d = np.array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41),

2726 ('Lancelot', 1.9, 38)],

2727 dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])

2728

2729 tgt = np.sort(d, order=['age', 'height'])

2730 assert_array_equal(np.partition(d, range(d.size),

2731 order=['age', 'height']),

2732 tgt)

2733 assert_array_equal(d[np.argpartition(d, range(d.size),

2734 order=['age', 'height'])],

2735 tgt)

2736 for k in range(d.size):

2737 assert_equal(np.partition(d, k, order=['age', 'height'])[k],

2738 tgt[k])

2739 assert_equal(d[np.argpartition(d, k, order=['age', 'height'])][k],

2740 tgt[k])

2741

2742 d = np.array(['Galahad', 'Arthur', 'zebra', 'Lancelot'])

2743 tgt = np.sort(d)

2744 assert_array_equal(np.partition(d, range(d.size)), tgt)

2745 for k in range(d.size):

2746 assert_equal(np.partition(d, k)[k], tgt[k])

2747 assert_equal(d[np.argpartition(d, k)][k], tgt[k])

2748

2749 def test_partition_unicode_kind(self):

2750 d = np.arange(10)

2751 k = b'\xc3\xa4'.decode("UTF8")

2752 assert_raises(ValueError, d.partition, 2, kind=k)

2753 assert_raises(ValueError, d.argpartition, 2, kind=k)

2754

2755 def test_partition_fuzz(self):

2756 # a few rounds of random data testing

2757 for j in range(10, 30):

2758 for i in range(1, j - 2):

2759 d = np.arange(j)

2760 np.random.shuffle(d)

2761 d = d % np.random.randint(2, 30)

2762 idx = np.random.randint(d.size)

2763 kth = [0, idx, i, i + 1]

2764 tgt = np.sort(d)[kth]

2765 assert_array_equal(np.partition(d, kth)[kth], tgt,

2766 err_msg="data: %r\n kth: %r" % (d, kth))

2767

2768 def test_argpartition_gh5524(self):

2769 # A test for functionality of argpartition on lists.

2770 d = [6,7,3,2,9,0]

2771 p = np.argpartition(d,1)

2772 self.assert_partitioned(np.array(d)[p],[1])

2773

2774 def test_flatten(self):

2775 x0 = np.array([[1, 2, 3], [4, 5, 6]], np.int32)

2776 x1 = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], np.int32)

2777 y0 = np.array([1, 2, 3, 4, 5, 6], np.int32)

2778 y0f = np.array([1, 4, 2, 5, 3, 6], np.int32)

2779 y1 = np.array([1, 2, 3, 4, 5, 6, 7, 8], np.int32)

2780 y1f = np.array([1, 5, 3, 7, 2, 6, 4, 8], np.int32)

2781 assert_equal(x0.flatten(), y0)

2782 assert_equal(x0.flatten('F'), y0f)

2783 assert_equal(x0.flatten('F'), x0.T.flatten())

2784 assert_equal(x1.flatten(), y1)

2785 assert_equal(x1.flatten('F'), y1f)

2786 assert_equal(x1.flatten('F'), x1.T.flatten())

2787

2788

2789 @pytest.mark.parametrize('func', (np.dot, np.matmul))

2790 def test_arr_mult(self, func):

2791 a = np.array([[1, 0], [0, 1]])

2792 b = np.array([[0, 1], [1, 0]])

2793 c = np.array([[9, 1], [1, -9]])

2794 d = np.arange(24).reshape(4, 6)

2795 ddt = np.array(

2796 [[ 55, 145, 235, 325],

2797 [ 145, 451, 757, 1063],

2798 [ 235, 757, 1279, 1801],

2799 [ 325, 1063, 1801, 2539]]

2800 )

2801 dtd = np.array(

2802 [[504, 540, 576, 612, 648, 684],

2803 [540, 580, 620, 660, 700, 740],

2804 [576, 620, 664, 708, 752, 796],

2805 [612, 660, 708, 756, 804, 852],

2806 [648, 700, 752, 804, 856, 908],

2807 [684, 740, 796, 852, 908, 964]]

2808 )

2809

2810

2811 # gemm vs syrk optimizations

2812 for et in [np.float32, np.float64, np.complex64, np.complex128]:

2813 eaf = a.astype(et)

2814 assert_equal(func(eaf, eaf), eaf)

2815 assert_equal(func(eaf.T, eaf), eaf)

2816 assert_equal(func(eaf, eaf.T), eaf)

2817 assert_equal(func(eaf.T, eaf.T), eaf)

2818 assert_equal(func(eaf.T.copy(), eaf), eaf)

2819 assert_equal(func(eaf, eaf.T.copy()), eaf)

2820 assert_equal(func(eaf.T.copy(), eaf.T.copy()), eaf)

2821

2822 # syrk validations

2823 for et in [np.float32, np.float64, np.complex64, np.complex128]:

2824 eaf = a.astype(et)

2825 ebf = b.astype(et)

2826 assert_equal(func(ebf, ebf), eaf)

2827 assert_equal(func(ebf.T, ebf), eaf)

2828 assert_equal(func(ebf, ebf.T), eaf)

2829 assert_equal(func(ebf.T, ebf.T), eaf)

2830

2831 # syrk - different shape, stride, and view validations

2832 for et in [np.float32, np.float64, np.complex64, np.complex128]:

2833 edf = d.astype(et)

2834 assert_equal(

2835 func(edf[::-1, :], edf.T),

2836 func(edf[::-1, :].copy(), edf.T.copy())

2837 )

2838 assert_equal(

2839 func(edf[:, ::-1], edf.T),

2840 func(edf[:, ::-1].copy(), edf.T.copy())

2841 )

2842 assert_equal(

2843 func(edf, edf[::-1, :].T),

2844 func(edf, edf[::-1, :].T.copy())

2845 )

2846 assert_equal(

2847 func(edf, edf[:, ::-1].T),

2848 func(edf, edf[:, ::-1].T.copy())

2849 )

2850 assert_equal(

2851 func(edf[:edf.shape[0] // 2, :], edf[::2, :].T),

2852 func(edf[:edf.shape[0] // 2, :].copy(), edf[::2, :].T.copy())

2853 )

2854 assert_equal(

2855 func(edf[::2, :], edf[:edf.shape[0] // 2, :].T),

2856 func(edf[::2, :].copy(), edf[:edf.shape[0] // 2, :].T.copy())

2857 )

2858

2859 # syrk - different shape

2860 for et in [np.float32, np.float64, np.complex64, np.complex128]:

2861 edf = d.astype(et)

2862 eddtf = ddt.astype(et)

2863 edtdf = dtd.astype(et)

2864 assert_equal(func(edf, edf.T), eddtf)

2865 assert_equal(func(edf.T, edf), edtdf)

2866

2867 @pytest.mark.parametrize('func', (np.dot, np.matmul))

2868 @pytest.mark.parametrize('dtype', 'ifdFD')

2869 def test_no_dgemv(self, func, dtype):

2870 # check vector arg for contiguous before gemv

2871 # gh-12156

2872 a = np.arange(8.0, dtype=dtype).reshape(2, 4)

2873 b = np.broadcast_to(1., (4, 1))

2874 ret1 = func(a, b)

2875 ret2 = func(a, b.copy())

2876 assert_equal(ret1, ret2)

2877

2878 ret1 = func(b.T, a.T)

2879 ret2 = func(b.T.copy(), a.T)

2880 assert_equal(ret1, ret2)

2881

2882 # check for unaligned data

2883 dt = np.dtype(dtype)

2884 a = np.zeros(8 * dt.itemsize // 2 + 1, dtype='int16')[1:].view(dtype)

2885 a = a.reshape(2, 4)

2886 b = a[0]

2887 # make sure it is not aligned

2888 assert_(a.__array_interface__['data'][0] % dt.itemsize != 0)

2889 ret1 = func(a, b)

2890 ret2 = func(a.copy(), b.copy())

2891 assert_equal(ret1, ret2)

2892

2893 ret1 = func(b.T, a.T)

2894 ret2 = func(b.T.copy(), a.T.copy())

2895 assert_equal(ret1, ret2)

2896

2897 def test_dot(self):

2898 a = np.array([[1, 0], [0, 1]])

2899 b = np.array([[0, 1], [1, 0]])

2900 c = np.array([[9, 1], [1, -9]])

2901 # function versus methods

2902 assert_equal(np.dot(a, b), a.dot(b))

2903 assert_equal(np.dot(np.dot(a, b), c), a.dot(b).dot(c))

2904

2905 # test passing in an output array

2906 c = np.zeros_like(a)

2907 a.dot(b, c)

2908 assert_equal(c, np.dot(a, b))

2909

2910 # test keyword args

2911 c = np.zeros_like(a)

2912 a.dot(b=b, out=c)

2913 assert_equal(c, np.dot(a, b))

2914

2915 def test_dot_type_mismatch(self):

2916 c = 1.

2917 A = np.array((1,1), dtype='i,i')

2918

2919 assert_raises(TypeError, np.dot, c, A)

2920 assert_raises(TypeError, np.dot, A, c)

2921

2922 def test_dot_out_mem_overlap(self):

2923 np.random.seed(1)

2924

2925 # Test BLAS and non-BLAS code paths, including all dtypes

2926 # that dot() supports

2927 dtypes = [np.dtype(code) for code in np.typecodes['All']

2928 if code not in 'USVM']

2929 for dtype in dtypes:

2930 a = np.random.rand(3, 3).astype(dtype)

2931

2932 # Valid dot() output arrays must be aligned

2933 b = _aligned_zeros((3, 3), dtype=dtype)

2934 b[...] = np.random.rand(3, 3)

2935

2936 y = np.dot(a, b)

2937 x = np.dot(a, b, out=b)

2938 assert_equal(x, y, err_msg=repr(dtype))

2939

2940 # Check invalid output array

2941 assert_raises(ValueError, np.dot, a, b, out=b[::2])

2942 assert_raises(ValueError, np.dot, a, b, out=b.T)

2943

2944 def test_dot_matmul_out(self):

2945 # gh-9641

2946 class Sub(np.ndarray):

2947 pass

2948 a = np.ones((2, 2)).view(Sub)

2949 b = np.ones((2, 2)).view(Sub)

2950 out = np.ones((2, 2))

2951

2952 # make sure out can be any ndarray (not only subclass of inputs)

2953 np.dot(a, b, out=out)

2954 np.matmul(a, b, out=out)

2955

2956 def test_dot_matmul_inner_array_casting_fails(self):

2957

2958 class A:

2959 def __array__(self, *args, **kwargs):

2960 raise NotImplementedError

2961

2962 # Don't override the error from calling __array__()

2963 assert_raises(NotImplementedError, np.dot, A(), A())

2964 assert_raises(NotImplementedError, np.matmul, A(), A())

2965 assert_raises(NotImplementedError, np.inner, A(), A())

2966

2967 def test_matmul_out(self):

2968 # overlapping memory

2969 a = np.arange(18).reshape(2, 3, 3)

2970 b = np.matmul(a, a)

2971 c = np.matmul(a, a, out=a)

2972 assert_(c is a)

2973 assert_equal(c, b)

2974 a = np.arange(18).reshape(2, 3, 3)

2975 c = np.matmul(a, a, out=a[::-1, ...])

2976 assert_(c.base is a.base)

2977 assert_equal(c, b)

2978

2979 def test_diagonal(self):

2980 a = np.arange(12).reshape((3, 4))

2981 assert_equal(a.diagonal(), [0, 5, 10])

2982 assert_equal(a.diagonal(0), [0, 5, 10])

2983 assert_equal(a.diagonal(1), [1, 6, 11])

2984 assert_equal(a.diagonal(-1), [4, 9])

2985 assert_raises(np.AxisError, a.diagonal, axis1=0, axis2=5)

2986 assert_raises(np.AxisError, a.diagonal, axis1=5, axis2=0)

2987 assert_raises(np.AxisError, a.diagonal, axis1=5, axis2=5)

2988 assert_raises(ValueError, a.diagonal, axis1=1, axis2=1)

2989

2990 b = np.arange(8).reshape((2, 2, 2))

2991 assert_equal(b.diagonal(), [[0, 6], [1, 7]])

2992 assert_equal(b.diagonal(0), [[0, 6], [1, 7]])

2993 assert_equal(b.diagonal(1), [[2], [3]])

2994 assert_equal(b.diagonal(-1), [[4], [5]])

2995 assert_raises(ValueError, b.diagonal, axis1=0, axis2=0)

2996 assert_equal(b.diagonal(0, 1, 2), [[0, 3], [4, 7]])

2997 assert_equal(b.diagonal(0, 0, 1), [[0, 6], [1, 7]])

2998 assert_equal(b.diagonal(offset=1, axis1=0, axis2=2), [[1], [3]])

2999 # Order of axis argument doesn't matter:

3000 assert_equal(b.diagonal(0, 2, 1), [[0, 3], [4, 7]])

3001

3002 def test_diagonal_view_notwriteable(self):

3003 a = np.eye(3).diagonal()

3004 assert_(not a.flags.writeable)

3005 assert_(not a.flags.owndata)

3006

3007 a = np.diagonal(np.eye(3))

3008 assert_(not a.flags.writeable)

3009 assert_(not a.flags.owndata)

3010

3011 a = np.diag(np.eye(3))

3012 assert_(not a.flags.writeable)

3013 assert_(not a.flags.owndata)

3014

3015 def test_diagonal_memleak(self):

3016 # Regression test for a bug that crept in at one point

3017 a = np.zeros((100, 100))

3018 if HAS_REFCOUNT:

3019 assert_(sys.getrefcount(a) < 50)

3020 for i in range(100):

3021 a.diagonal()

3022 if HAS_REFCOUNT:

3023 assert_(sys.getrefcount(a) < 50)

3024

3025 def test_size_zero_memleak(self):

3026 # Regression test for issue 9615

3027 # Exercises a special-case code path for dot products of length

3028 # zero in cblasfuncs (making it is specific to floating dtypes).

3029 a = np.array([], dtype=np.float64)

3030 x = np.array(2.0)

3031 for _ in range(100):

3032 np.dot(a, a, out=x)

3033 if HAS_REFCOUNT:

3034 assert_(sys.getrefcount(x) < 50)

3035

3036 def test_trace(self):

3037 a = np.arange(12).reshape((3, 4))

3038 assert_equal(a.trace(), 15)

3039 assert_equal(a.trace(0), 15)

3040 assert_equal(a.trace(1), 18)

3041 assert_equal(a.trace(-1), 13)

3042

3043 b = np.arange(8).reshape((2, 2, 2))

3044 assert_equal(b.trace(), [6, 8])

3045 assert_equal(b.trace(0), [6, 8])

3046 assert_equal(b.trace(1), [2, 3])

3047 assert_equal(b.trace(-1), [4, 5])

3048 assert_equal(b.trace(0, 0, 1), [6, 8])

3049 assert_equal(b.trace(0, 0, 2), [5, 9])

3050 assert_equal(b.trace(0, 1, 2), [3, 11])

3051 assert_equal(b.trace(offset=1, axis1=0, axis2=2), [1, 3])

3052

3053 def test_trace_subclass(self):

3054 # The class would need to overwrite trace to ensure single-element

3055 # output also has the right subclass.

3056 class MyArray(np.ndarray):

3057 pass

3058

3059 b = np.arange(8).reshape((2, 2, 2)).view(MyArray)

3060 t = b.trace()

3061 assert_(isinstance(t, MyArray))

3062

3063 def test_put(self):

3064 icodes = np.typecodes['AllInteger']

3065 fcodes = np.typecodes['AllFloat']

3066 for dt in icodes + fcodes + 'O':

3067 tgt = np.array([0, 1, 0, 3, 0, 5], dtype=dt)

3068

3069 # test 1-d

3070 a = np.zeros(6, dtype=dt)

3071 a.put([1, 3, 5], [1, 3, 5])

3072 assert_equal(a, tgt)

3073

3074 # test 2-d

3075 a = np.zeros((2, 3), dtype=dt)

3076 a.put([1, 3, 5], [1, 3, 5])

3077 assert_equal(a, tgt.reshape(2, 3))

3078

3079 for dt in '?':

3080 tgt = np.array([False, True, False, True, False, True], dtype=dt)

3081

3082 # test 1-d

3083 a = np.zeros(6, dtype=dt)

3084 a.put([1, 3, 5], [True]*3)

3085 assert_equal(a, tgt)

3086

3087 # test 2-d

3088 a = np.zeros((2, 3), dtype=dt)

3089 a.put([1, 3, 5], [True]*3)

3090 assert_equal(a, tgt.reshape(2, 3))

3091

3092 # check must be writeable

3093 a = np.zeros(6)

3094 a.flags.writeable = False

3095 assert_raises(ValueError, a.put, [1, 3, 5], [1, 3, 5])

3096

3097 # when calling np.put, make sure a

3098 # TypeError is raised if the object

3099 # isn't an ndarray

3100 bad_array = [1, 2, 3]

3101 assert_raises(TypeError, np.put, bad_array, [0, 2], 5)

3102

3103 def test_ravel(self):

3104 a = np.array([[0, 1], [2, 3]])

3105 assert_equal(a.ravel(), [0, 1, 2, 3])

3106 assert_(not a.ravel().flags.owndata)

3107 assert_equal(a.ravel('F'), [0, 2, 1, 3])

3108 assert_equal(a.ravel(order='C'), [0, 1, 2, 3])

3109 assert_equal(a.ravel(order='F'), [0, 2, 1, 3])

3110 assert_equal(a.ravel(order='A'), [0, 1, 2, 3])

3111 assert_(not a.ravel(order='A').flags.owndata)

3112 assert_equal(a.ravel(order='K'), [0, 1, 2, 3])

3113 assert_(not a.ravel(order='K').flags.owndata)

3114 assert_equal(a.ravel(), a.reshape(-1))

3115

3116 a = np.array([[0, 1], [2, 3]], order='F')

3117 assert_equal(a.ravel(), [0, 1, 2, 3])

3118 assert_equal(a.ravel(order='A'), [0, 2, 1, 3])

3119 assert_equal(a.ravel(order='K'), [0, 2, 1, 3])

3120 assert_(not a.ravel(order='A').flags.owndata)

3121 assert_(not a.ravel(order='K').flags.owndata)

3122 assert_equal(a.ravel(), a.reshape(-1))

3123 assert_equal(a.ravel(order='A'), a.reshape(-1, order='A'))

3124

3125 a = np.array([[0, 1], [2, 3]])[::-1, :]

3126 assert_equal(a.ravel(), [2, 3, 0, 1])

3127 assert_equal(a.ravel(order='C'), [2, 3, 0, 1])

3128 assert_equal(a.ravel(order='F'), [2, 0, 3, 1])

3129 assert_equal(a.ravel(order='A'), [2, 3, 0, 1])

3130 # 'K' doesn't reverse the axes of negative strides

3131 assert_equal(a.ravel(order='K'), [2, 3, 0, 1])

3132 assert_(a.ravel(order='K').flags.owndata)

3133

3134 # Test simple 1-d copy behaviour:

3135 a = np.arange(10)[::2]

3136 assert_(a.ravel('K').flags.owndata)

3137 assert_(a.ravel('C').flags.owndata)

3138 assert_(a.ravel('F').flags.owndata)

3139

3140 # Not contiguous and 1-sized axis with non matching stride

3141 a = np.arange(2**3 * 2)[::2]

3142 a = a.reshape(2, 1, 2, 2).swapaxes(-1, -2)

3143 strides = list(a.strides)

3144 strides[1] = 123

3145 a.strides = strides

3146 assert_(a.ravel(order='K').flags.owndata)

3147 assert_equal(a.ravel('K'), np.arange(0, 15, 2))

3148

3149 # contiguous and 1-sized axis with non matching stride works:

3150 a = np.arange(2**3)

3151 a = a.reshape(2, 1, 2, 2).swapaxes(-1, -2)

3152 strides = list(a.strides)

3153 strides[1] = 123

3154 a.strides = strides

3155 assert_(np.may_share_memory(a.ravel(order='K'), a))

3156 assert_equal(a.ravel(order='K'), np.arange(2**3))

3157

3158 # Test negative strides (not very interesting since non-contiguous):

3159 a = np.arange(4)[::-1].reshape(2, 2)

3160 assert_(a.ravel(order='C').flags.owndata)

3161 assert_(a.ravel(order='K').flags.owndata)

3162 assert_equal(a.ravel('C'), [3, 2, 1, 0])

3163 assert_equal(a.ravel('K'), [3, 2, 1, 0])

3164

3165 # 1-element tidy strides test (NPY_RELAXED_STRIDES_CHECKING):

3166 a = np.array([[1]])

3167 a.strides = (123, 432)

3168 # If the stride is not 8, NPY_RELAXED_STRIDES_CHECKING is messing

3169 # them up on purpose:

3170 if np.ones(1).strides == (8,):

3171 assert_(np.may_share_memory(a.ravel('K'), a))

3172 assert_equal(a.ravel('K').strides, (a.dtype.itemsize,))

3173

3174 for order in ('C', 'F', 'A', 'K'):

3175 # 0-d corner case:

3176 a = np.array(0)

3177 assert_equal(a.ravel(order), [0])

3178 assert_(np.may_share_memory(a.ravel(order), a))

3179

3180 # Test that certain non-inplace ravels work right (mostly) for 'K':

3181 b = np.arange(2**4 * 2)[::2].reshape(2, 2, 2, 2)

3182 a = b[..., ::2]

3183 assert_equal(a.ravel('K'), [0, 4, 8, 12, 16, 20, 24, 28])

3184 assert_equal(a.ravel('C'), [0, 4, 8, 12, 16, 20, 24, 28])

3185 assert_equal(a.ravel('A'), [0, 4, 8, 12, 16, 20, 24, 28])

3186 assert_equal(a.ravel('F'), [0, 16, 8, 24, 4, 20, 12, 28])

3187

3188 a = b[::2, ...]

3189 assert_equal(a.ravel('K'), [0, 2, 4, 6, 8, 10, 12, 14])

3190 assert_equal(a.ravel('C'), [0, 2, 4, 6, 8, 10, 12, 14])

3191 assert_equal(a.ravel('A'), [0, 2, 4, 6, 8, 10, 12, 14])

3192 assert_equal(a.ravel('F'), [0, 8, 4, 12, 2, 10, 6, 14])

3193

3194 def test_ravel_subclass(self):

3195 class ArraySubclass(np.ndarray):

3196 pass

3197

3198 a = np.arange(10).view(ArraySubclass)

3199 assert_(isinstance(a.ravel('C'), ArraySubclass))

3200 assert_(isinstance(a.ravel('F'), ArraySubclass))

3201 assert_(isinstance(a.ravel('A'), ArraySubclass))

3202 assert_(isinstance(a.ravel('K'), ArraySubclass))

3203

3204 a = np.arange(10)[::2].view(ArraySubclass)

3205 assert_(isinstance(a.ravel('C'), ArraySubclass))

3206 assert_(isinstance(a.ravel('F'), ArraySubclass))

3207 assert_(isinstance(a.ravel('A'), ArraySubclass))

3208 assert_(isinstance(a.ravel('K'), ArraySubclass))

3209

3210 def test_swapaxes(self):

3211 a = np.arange(1*2*3*4).reshape(1, 2, 3, 4).copy()

3212 idx = np.indices(a.shape)

3213 assert_(a.flags['OWNDATA'])

3214 b = a.copy()

3215 # check exceptions

3216 assert_raises(np.AxisError, a.swapaxes, -5, 0)

3217 assert_raises(np.AxisError, a.swapaxes, 4, 0)

3218 assert_raises(np.AxisError, a.swapaxes, 0, -5)

3219 assert_raises(np.AxisError, a.swapaxes, 0, 4)

3220

3221 for i in range(-4, 4):

3222 for j in range(-4, 4):

3223 for k, src in enumerate((a, b)):

3224 c = src.swapaxes(i, j)

3225 # check shape

3226 shape = list(src.shape)

3227 shape[i] = src.shape[j]

3228 shape[j] = src.shape[i]

3229 assert_equal(c.shape, shape, str((i, j, k)))

3230 # check array contents

3231 i0, i1, i2, i3 = [dim-1 for dim in c.shape]

3232 j0, j1, j2, j3 = [dim-1 for dim in src.shape]

3233 assert_equal(src[idx[j0], idx[j1], idx[j2], idx[j3]],

3234 c[idx[i0], idx[i1], idx[i2], idx[i3]],

3235 str((i, j, k)))

3236 # check a view is always returned, gh-5260

3237 assert_(not c.flags['OWNDATA'], str((i, j, k)))

3238 # check on non-contiguous input array

3239 if k == 1:

3240 b = c

3241

3242 def test_conjugate(self):

3243 a = np.array([1-1j, 1+1j, 23+23.0j])

3244 ac = a.conj()

3245 assert_equal(a.real, ac.real)

3246 assert_equal(a.imag, -ac.imag)

3247 assert_equal(ac, a.conjugate())

3248 assert_equal(ac, np.conjugate(a))

3249

3250 a = np.array([1-1j, 1+1j, 23+23.0j], 'F')

3251 ac = a.conj()

3252 assert_equal(a.real, ac.real)

3253 assert_equal(a.imag, -ac.imag)

3254 assert_equal(ac, a.conjugate())

3255 assert_equal(ac, np.conjugate(a))

3256

3257 a = np.array([1, 2, 3])

3258 ac = a.conj()

3259 assert_equal(a, ac)

3260 assert_equal(ac, a.conjugate())

3261 assert_equal(ac, np.conjugate(a))

3262

3263 a = np.array([1.0, 2.0, 3.0])

3264 ac = a.conj()

3265 assert_equal(a, ac)

3266 assert_equal(ac, a.conjugate())

3267 assert_equal(ac, np.conjugate(a))

3268

3269 a = np.array([1-1j, 1+1j, 1, 2.0], object)

3270 ac = a.conj()

3271 assert_equal(ac, [k.conjugate() for k in a])

3272 assert_equal(ac, a.conjugate())

3273 assert_equal(ac, np.conjugate(a))

3274

3275 a = np.array([1-1j, 1, 2.0, 'f'], object)

3276 assert_raises(TypeError, lambda: a.conj())

3277 assert_raises(TypeError, lambda: a.conjugate())

3278

3279 def test__complex__(self):

3280 dtypes = ['i1', 'i2', 'i4', 'i8',

3281 'u1', 'u2', 'u4', 'u8',

3282 'f', 'd', 'g', 'F', 'D', 'G',

3283 '?', 'O']

3284 for dt in dtypes:

3285 a = np.array(7, dtype=dt)

3286 b = np.array([7], dtype=dt)

3287 c = np.array([[[[[7]]]]], dtype=dt)

3288

3289 msg = 'dtype: {0}'.format(dt)

3290 ap = complex(a)

3291 assert_equal(ap, a, msg)

3292 bp = complex(b)

3293 assert_equal(bp, b, msg)

3294 cp = complex(c)

3295 assert_equal(cp, c, msg)

3296

3297 def test__complex__should_not_work(self):

3298 dtypes = ['i1', 'i2', 'i4', 'i8',

3299 'u1', 'u2', 'u4', 'u8',

3300 'f', 'd', 'g', 'F', 'D', 'G',

3301 '?', 'O']

3302 for dt in dtypes:

3303 a = np.array([1, 2, 3], dtype=dt)

3304 assert_raises(TypeError, complex, a)

3305

3306 dt = np.dtype([('a', 'f8'), ('b', 'i1')])

3307 b = np.array((1.0, 3), dtype=dt)

3308 assert_raises(TypeError, complex, b)

3309

3310 c = np.array([(1.0, 3), (2e-3, 7)], dtype=dt)

3311 assert_raises(TypeError, complex, c)

3312

3313 d = np.array('1+1j')

3314 assert_raises(TypeError, complex, d)

3315

3316 e = np.array(['1+1j'], 'U')

3317 assert_raises(TypeError, complex, e)

3318

3319class TestCequenceMethods:

3320 def test_array_contains(self):

3321 assert_(4.0 in np.arange(16.).reshape(4,4))

3322 assert_(20.0 not in np.arange(16.).reshape(4,4))

3323

3324class TestBinop:

3325 def test_inplace(self):

3326 # test refcount 1 inplace conversion

3327 assert_array_almost_equal(np.array([0.5]) * np.array([1.0, 2.0]),

3328 [0.5, 1.0])

3329

3330 d = np.array([0.5, 0.5])[::2]

3331 assert_array_almost_equal(d * (d * np.array([1.0, 2.0])),

3332 [0.25, 0.5])

3333

3334 a = np.array([0.5])

3335 b = np.array([0.5])

3336 c = a + b

3337 c = a - b

3338 c = a * b

3339 c = a / b

3340 assert_equal(a, b)

3341 assert_almost_equal(c, 1.)

3342

3343 c = a + b * 2. / b * a - a / b

3344 assert_equal(a, b)

3345 assert_equal(c, 0.5)

3346

3347 # true divide

3348 a = np.array([5])

3349 b = np.array([3])

3350 c = (a * a) / b

3351

3352 assert_almost_equal(c, 25 / 3)

3353 assert_equal(a, 5)

3354 assert_equal(b, 3)

3355

3356 # ndarray.__rop__ always calls ufunc

3357 # ndarray.__iop__ always calls ufunc

3358 # ndarray.__op__, __rop__:

3359 # - defer if other has __array_ufunc__ and it is None

3360 # or other is not a subclass and has higher array priority

3361 # - else, call ufunc

3362 def test_ufunc_binop_interaction(self):

3363 # Python method name (without underscores)

3364 # -> (numpy ufunc, has_in_place_version, preferred_dtype)

3365 ops = {

3366 'add': (np.add, True, float),

3367 'sub': (np.subtract, True, float),

3368 'mul': (np.multiply, True, float),

3369 'truediv': (np.true_divide, True, float),

3370 'floordiv': (np.floor_divide, True, float),

3371 'mod': (np.remainder, True, float),

3372 'divmod': (np.divmod, False, float),

3373 'pow': (np.power, True, int),

3374 'lshift': (np.left_shift, True, int),

3375 'rshift': (np.right_shift, True, int),

3376 'and': (np.bitwise_and, True, int),

3377 'xor': (np.bitwise_xor, True, int),

3378 'or': (np.bitwise_or, True, int),

3379 'matmul': (np.matmul, False, float),

3380 # 'ge': (np.less_equal, False),

3381 # 'gt': (np.less, False),

3382 # 'le': (np.greater_equal, False),

3383 # 'lt': (np.greater, False),

3384 # 'eq': (np.equal, False),

3385 # 'ne': (np.not_equal, False),

3386 }

3387

3388 class Coerced(Exception):

3389 pass

3390

3391 def array_impl(self):

3392 raise Coerced

3393

3394 def op_impl(self, other):

3395 return "forward"

3396

3397 def rop_impl(self, other):

3398 return "reverse"

3399

3400 def iop_impl(self, other):

3401 return "in-place"

3402

3403 def array_ufunc_impl(self, ufunc, method, *args, **kwargs):

3404 return ("__array_ufunc__", ufunc, method, args, kwargs)

3405

3406 # Create an object with the given base, in the given module, with a

3407 # bunch of placeholder __op__ methods, and optionally a

3408 # __array_ufunc__ and __array_priority__.

3409 def make_obj(base, array_priority=False, array_ufunc=False,

3410 alleged_module="__main__"):

3411 class_namespace = {"__array__": array_impl}

3412 if array_priority is not False:

3413 class_namespace["__array_priority__"] = array_priority

3414 for op in ops:

3415 class_namespace["__{0}__".format(op)] = op_impl

3416 class_namespace["__r{0}__".format(op)] = rop_impl

3417 class_namespace["__i{0}__".format(op)] = iop_impl

3418 if array_ufunc is not False:

3419 class_namespace["__array_ufunc__"] = array_ufunc

3420 eval_namespace = {"base": base,

3421 "class_namespace": class_namespace,

3422 "__name__": alleged_module,

3423 }

3424 MyType = eval("type('MyType', (base,), class_namespace)",

3425 eval_namespace)

3426 if issubclass(MyType, np.ndarray):

3427 # Use this range to avoid special case weirdnesses around

3428 # divide-by-0, pow(x, 2), overflow due to pow(big, big), etc.

3429 return np.arange(3, 7).reshape(2, 2).view(MyType)

3430 else:

3431 return MyType()

3432

3433 def check(obj, binop_override_expected, ufunc_override_expected,

3434 inplace_override_expected, check_scalar=True):

3435 for op, (ufunc, has_inplace, dtype) in ops.items():

3436 err_msg = ('op: %s, ufunc: %s, has_inplace: %s, dtype: %s'

3437 % (op, ufunc, has_inplace, dtype))

3438 check_objs = [np.arange(3, 7, dtype=dtype).reshape(2, 2)]

3439 if check_scalar:

3440 check_objs.append(check_objs[0][0])

3441 for arr in check_objs:

3442 arr_method = getattr(arr, "__{0}__".format(op))

3443

3444 def first_out_arg(result):

3445 if op == "divmod":

3446 assert_(isinstance(result, tuple))

3447 return result[0]

3448 else:

3449 return result

3450

3451 # arr __op__ obj

3452 if binop_override_expected:

3453 assert_equal(arr_method(obj), NotImplemented, err_msg)

3454 elif ufunc_override_expected:

3455 assert_equal(arr_method(obj)[0], "__array_ufunc__",

3456 err_msg)

3457 else:

3458 if (isinstance(obj, np.ndarray) and

3459 (type(obj).__array_ufunc__ is

3460 np.ndarray.__array_ufunc__)):

3461 # __array__ gets ignored

3462 res = first_out_arg(arr_method(obj))

3463 assert_(res.__class__ is obj.__class__, err_msg)

3464 else:

3465 assert_raises((TypeError, Coerced),

3466 arr_method, obj, err_msg=err_msg)

3467 # obj __op__ arr

3468 arr_rmethod = getattr(arr, "__r{0}__".format(op))

3469 if ufunc_override_expected:

3470 res = arr_rmethod(obj)

3471 assert_equal(res[0], "__array_ufunc__",

3472 err_msg=err_msg)

3473 assert_equal(res[1], ufunc, err_msg=err_msg)

3474 else:

3475 if (isinstance(obj, np.ndarray) and

3476 (type(obj).__array_ufunc__ is

3477 np.ndarray.__array_ufunc__)):

3478 # __array__ gets ignored

3479 res = first_out_arg(arr_rmethod(obj))

3480 assert_(res.__class__ is obj.__class__, err_msg)

3481 else:

3482 # __array_ufunc__ = "asdf" creates a TypeError

3483 assert_raises((TypeError, Coerced),

3484 arr_rmethod, obj, err_msg=err_msg)

3485

3486 # arr __iop__ obj

3487 # array scalars don't have in-place operators

3488 if has_inplace and isinstance(arr, np.ndarray):

3489 arr_imethod = getattr(arr, "__i{0}__".format(op))

3490 if inplace_override_expected:

3491 assert_equal(arr_method(obj), NotImplemented,

3492 err_msg=err_msg)

3493 elif ufunc_override_expected:

3494 res = arr_imethod(obj)

3495 assert_equal(res[0], "__array_ufunc__", err_msg)

3496 assert_equal(res[1], ufunc, err_msg)

3497 assert_(type(res[-1]["out"]) is tuple, err_msg)

3498 assert_(res[-1]["out"][0] is arr, err_msg)

3499 else:

3500 if (isinstance(obj, np.ndarray) and

3501 (type(obj).__array_ufunc__ is

3502 np.ndarray.__array_ufunc__)):

3503 # __array__ gets ignored

3504 assert_(arr_imethod(obj) is arr, err_msg)

3505 else:

3506 assert_raises((TypeError, Coerced),

3507 arr_imethod, obj,

3508 err_msg=err_msg)

3509

3510 op_fn = getattr(operator, op, None)

3511 if op_fn is None:

3512 op_fn = getattr(operator, op + "_", None)

3513 if op_fn is None:

3514 op_fn = getattr(builtins, op)

3515 assert_equal(op_fn(obj, arr), "forward", err_msg)

3516 if not isinstance(obj, np.ndarray):

3517 if binop_override_expected:

3518 assert_equal(op_fn(arr, obj), "reverse", err_msg)

3519 elif ufunc_override_expected:

3520 assert_equal(op_fn(arr, obj)[0], "__array_ufunc__",

3521 err_msg)

3522 if ufunc_override_expected:

3523 assert_equal(ufunc(obj, arr)[0], "__array_ufunc__",

3524 err_msg)

3525

3526 # No array priority, no array_ufunc -> nothing called

3527 check(make_obj(object), False, False, False)

3528 # Negative array priority, no array_ufunc -> nothing called

3529 # (has to be very negative, because scalar priority is -1000000.0)

3530 check(make_obj(object, array_priority=-2**30), False, False, False)

3531 # Positive array priority, no array_ufunc -> binops and iops only

3532 check(make_obj(object, array_priority=1), True, False, True)

3533 # ndarray ignores array_priority for ndarray subclasses

3534 check(make_obj(np.ndarray, array_priority=1), False, False, False,

3535 check_scalar=False)

3536 # Positive array_priority and array_ufunc -> array_ufunc only

3537 check(make_obj(object, array_priority=1,

3538 array_ufunc=array_ufunc_impl), False, True, False)

3539 check(make_obj(np.ndarray, array_priority=1,

3540 array_ufunc=array_ufunc_impl), False, True, False)

3541 # array_ufunc set to None -> defer binops only

3542 check(make_obj(object, array_ufunc=None), True, False, False)

3543 check(make_obj(np.ndarray, array_ufunc=None), True, False, False,

3544 check_scalar=False)

3545

3546 def test_ufunc_override_normalize_signature(self):

3547 # gh-5674

3548 class SomeClass:

3549 def __array_ufunc__(self, ufunc, method, *inputs, **kw):

3550 return kw

3551

3552 a = SomeClass()

3553 kw = np.add(a, [1])

3554 assert_('sig' not in kw and 'signature' not in kw)

3555 kw = np.add(a, [1], sig='ii->i')

3556 assert_('sig' not in kw and 'signature' in kw)

3557 assert_equal(kw['signature'], 'ii->i')

3558 kw = np.add(a, [1], signature='ii->i')

3559 assert_('sig' not in kw and 'signature' in kw)

3560 assert_equal(kw['signature'], 'ii->i')

3561

3562 def test_array_ufunc_index(self):

3563 # Check that index is set appropriately, also if only an output

3564 # is passed on (latter is another regression tests for github bug 4753)

3565 # This also checks implicitly that 'out' is always a tuple.

3566 class CheckIndex:

3567 def __array_ufunc__(self, ufunc, method, *inputs, **kw):

3568 for i, a in enumerate(inputs):

3569 if a is self:

3570 return i

3571 # calls below mean we must be in an output.

3572 for j, a in enumerate(kw['out']):

3573 if a is self:

3574 return (j,)

3575

3576 a = CheckIndex()

3577 dummy = np.arange(2.)

3578 # 1 input, 1 output

3579 assert_equal(np.sin(a), 0)

3580 assert_equal(np.sin(dummy, a), (0,))

3581 assert_equal(np.sin(dummy, out=a), (0,))

3582 assert_equal(np.sin(dummy, out=(a,)), (0,))

3583 assert_equal(np.sin(a, a), 0)

3584 assert_equal(np.sin(a, out=a), 0)

3585 assert_equal(np.sin(a, out=(a,)), 0)

3586 # 1 input, 2 outputs

3587 assert_equal(np.modf(dummy, a), (0,))

3588 assert_equal(np.modf(dummy, None, a), (1,))

3589 assert_equal(np.modf(dummy, dummy, a), (1,))

3590 assert_equal(np.modf(dummy, out=(a, None)), (0,))

3591 assert_equal(np.modf(dummy, out=(a, dummy)), (0,))

3592 assert_equal(np.modf(dummy, out=(None, a)), (1,))

3593 assert_equal(np.modf(dummy, out=(dummy, a)), (1,))

3594 assert_equal(np.modf(a, out=(dummy, a)), 0)

3595 with assert_raises(TypeError):

3596 # Out argument must be tuple, since there are multiple outputs

3597 np.modf(dummy, out=a)

3598

3599 assert_raises(ValueError, np.modf, dummy, out=(a,))

3600

3601 # 2 inputs, 1 output

3602 assert_equal(np.add(a, dummy), 0)

3603 assert_equal(np.add(dummy, a), 1)

3604 assert_equal(np.add(dummy, dummy, a), (0,))

3605 assert_equal(np.add(dummy, a, a), 1)

3606 assert_equal(np.add(dummy, dummy, out=a), (0,))

3607 assert_equal(np.add(dummy, dummy, out=(a,)), (0,))

3608 assert_equal(np.add(a, dummy, out=a), 0)

3609

3610 def test_out_override(self):

3611 # regression test for github bug 4753

3612 class OutClass(np.ndarray):

3613 def __array_ufunc__(self, ufunc, method, *inputs, **kw):

3614 if 'out' in kw:

3615 tmp_kw = kw.copy()

3616 tmp_kw.pop('out')

3617 func = getattr(ufunc, method)

3618 kw['out'][0][...] = func(*inputs, **tmp_kw)

3619

3620 A = np.array([0]).view(OutClass)

3621 B = np.array([5])

3622 C = np.array([6])

3623 np.multiply(C, B, A)

3624 assert_equal(A[0], 30)

3625 assert_(isinstance(A, OutClass))

3626 A[0] = 0

3627 np.multiply(C, B, out=A)

3628 assert_equal(A[0], 30)

3629 assert_(isinstance(A, OutClass))

3630

3631 def test_pow_override_with_errors(self):

3632 # regression test for gh-9112

3633 class PowerOnly(np.ndarray):

3634 def __array_ufunc__(self, ufunc, method, *inputs, **kw):

3635 if ufunc is not np.power:

3636 raise NotImplementedError

3637 return "POWER!"

3638 # explicit cast to float, to ensure the fast power path is taken.

3639 a = np.array(5., dtype=np.float64).view(PowerOnly)

3640 assert_equal(a ** 2.5, "POWER!")

3641 with assert_raises(NotImplementedError):

3642 a ** 0.5

3643 with assert_raises(NotImplementedError):

3644 a ** 0

3645 with assert_raises(NotImplementedError):

3646 a ** 1

3647 with assert_raises(NotImplementedError):

3648 a ** -1

3649 with assert_raises(NotImplementedError):

3650 a ** 2

3651

3652 def test_pow_array_object_dtype(self):

3653 # test pow on arrays of object dtype

3654 class SomeClass:

3655 def __init__(self, num=None):

3656 self.num = num

3657

3658 # want to ensure a fast pow path is not taken

3659 def __mul__(self, other):

3660 raise AssertionError('__mul__ should not be called')

3661

3662 def __div__(self, other):

3663 raise AssertionError('__div__ should not be called')

3664

3665 def __pow__(self, exp):

3666 return SomeClass(num=self.num ** exp)

3667

3668 def __eq__(self, other):

3669 if isinstance(other, SomeClass):

3670 return self.num == other.num

3671

3672 __rpow__ = __pow__

3673

3674 def pow_for(exp, arr):

3675 return np.array([x ** exp for x in arr])

3676

3677 obj_arr = np.array([SomeClass(1), SomeClass(2), SomeClass(3)])

3678

3679 assert_equal(obj_arr ** 0.5, pow_for(0.5, obj_arr))

3680 assert_equal(obj_arr ** 0, pow_for(0, obj_arr))

3681 assert_equal(obj_arr ** 1, pow_for(1, obj_arr))

3682 assert_equal(obj_arr ** -1, pow_for(-1, obj_arr))

3683 assert_equal(obj_arr ** 2, pow_for(2, obj_arr))

3684

3685 def test_pos_array_ufunc_override(self):

3686 class A(np.ndarray):

3687 def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):

3688 return getattr(ufunc, method)(*[i.view(np.ndarray) for

3689 i in inputs], **kwargs)

3690 tst = np.array('foo').view(A)

3691 with assert_raises(TypeError):

3692 +tst

3693

3694

3695class TestTemporaryElide:

3696 # elision is only triggered on relatively large arrays

3697

3698 def test_extension_incref_elide(self):

3699 # test extension (e.g. cython) calling PyNumber_* slots without

3700 # increasing the reference counts

3701 #

3702 # def incref_elide(a):

3703 # d = input.copy() # refcount 1

3704 # return d, d + d # PyNumber_Add without increasing refcount

3705 from numpy.core._multiarray_tests import incref_elide

3706 d = np.ones(100000)

3707 orig, res = incref_elide(d)

3708 d + d

3709 # the return original should not be changed to an inplace operation

3710 assert_array_equal(orig, d)

3711 assert_array_equal(res, d + d)

3712

3713 def test_extension_incref_elide_stack(self):

3714 # scanning if the refcount == 1 object is on the python stack to check

3715 # that we are called directly from python is flawed as object may still

3716 # be above the stack pointer and we have no access to the top of it

3717 #

3718 # def incref_elide_l(d):

3719 # return l[4] + l[4] # PyNumber_Add without increasing refcount

3720 from numpy.core._multiarray_tests import incref_elide_l

3721 # padding with 1 makes sure the object on the stack is not overwritten

3722 l = [1, 1, 1, 1, np.ones(100000)]

3723 res = incref_elide_l(l)

3724 # the return original should not be changed to an inplace operation

3725 assert_array_equal(l[4], np.ones(100000))

3726 assert_array_equal(res, l[4] + l[4])

3727

3728 def test_temporary_with_cast(self):

3729 # check that we don't elide into a temporary which would need casting

3730 d = np.ones(200000, dtype=np.int64)

3731 assert_equal(((d + d) + 2**222).dtype, np.dtype('O'))

3732

3733 r = ((d + d) / 2)

3734 assert_equal(r.dtype, np.dtype('f8'))

3735

3736 r = np.true_divide((d + d), 2)

3737 assert_equal(r.dtype, np.dtype('f8'))

3738

3739 r = ((d + d) / 2.)

3740 assert_equal(r.dtype, np.dtype('f8'))

3741

3742 r = ((d + d) // 2)

3743 assert_equal(r.dtype, np.dtype(np.int64))

3744

3745 # commutative elision into the astype result

3746 f = np.ones(100000, dtype=np.float32)

3747 assert_equal(((f + f) + f.astype(np.float64)).dtype, np.dtype('f8'))

3748

3749 # no elision into lower type

3750 d = f.astype(np.float64)

3751 assert_equal(((f + f) + d).dtype, d.dtype)

3752 l = np.ones(100000, dtype=np.longdouble)

3753 assert_equal(((d + d) + l).dtype, l.dtype)

3754

3755 # test unary abs with different output dtype

3756 for dt in (np.complex64, np.complex128, np.clongdouble):

3757 c = np.ones(100000, dtype=dt)

3758 r = abs(c * 2.0)

3759 assert_equal(r.dtype, np.dtype('f%d' % (c.itemsize // 2)))

3760

3761 def test_elide_broadcast(self):

3762 # test no elision on broadcast to higher dimension

3763 # only triggers elision code path in debug mode as triggering it in

3764 # normal mode needs 256kb large matching dimension, so a lot of memory

3765 d = np.ones((2000, 1), dtype=int)

3766 b = np.ones((2000), dtype=bool)

3767 r = (1 - d) + b

3768 assert_equal(r, 1)

3769 assert_equal(r.shape, (2000, 2000))

3770

3771 def test_elide_scalar(self):

3772 # check inplace op does not create ndarray from scalars

3773 a = np.bool_()

3774 assert_(type(~(a & a)) is np.bool_)

3775

3776 def test_elide_scalar_readonly(self):

3777 # The imaginary part of a real array is readonly. This needs to go

3778 # through fast_scalar_power which is only called for powers of

3779 # +1, -1, 0, 0.5, and 2, so use 2. Also need valid refcount for

3780 # elision which can be gotten for the imaginary part of a real

3781 # array. Should not error.

3782 a = np.empty(100000, dtype=np.float64)

3783 a.imag ** 2

3784

3785 def test_elide_readonly(self):

3786 # don't try to elide readonly temporaries

3787 r = np.asarray(np.broadcast_to(np.zeros(1), 100000).flat) * 0.0

3788 assert_equal(r, 0)

3789

3790 def test_elide_updateifcopy(self):

3791 a = np.ones(2**20)[::2]

3792 b = a.flat.__array__() + 1

3793 del b

3794 assert_equal(a, 1)

3795

3796

3797class TestCAPI:

3798 def test_IsPythonScalar(self):

3799 from numpy.core._multiarray_tests import IsPythonScalar

3800 assert_(IsPythonScalar(b'foobar'))

3801 assert_(IsPythonScalar(1))

3802 assert_(IsPythonScalar(2**80))

3803 assert_(IsPythonScalar(2.))

3804 assert_(IsPythonScalar("a"))

3805

3806

3807class TestSubscripting:

3808 def test_test_zero_rank(self):

3809 x = np.array([1, 2, 3])

3810 assert_(isinstance(x[0], np.int_))

3811 assert_(type(x[0, ...]) is np.ndarray)

3812

3813

3814class TestPickling:

3815 @pytest.mark.skipif(pickle.HIGHEST_PROTOCOL >= 5,

3816 reason=('this tests the error messages when trying to'

3817 'protocol 5 although it is not available'))

3818 def test_correct_protocol5_error_message(self):

3819 array = np.arange(10)

3820

3821 if sys.version_info[:2] in ((3, 6), (3, 7)):

3822 # For the specific case of python3.6 and 3.7, raise a clear import

3823 # error about the pickle5 backport when trying to use protocol=5

3824 # without the pickle5 package

3825 with pytest.raises(ImportError):

3826 array.__reduce_ex__(5)

3827

3828 elif sys.version_info[:2] < (3, 6):

3829 # when calling __reduce_ex__ explicitly with protocol=5 on python

3830 # raise a ValueError saying that protocol 5 is not available for

3831 # this python version

3832 with pytest.raises(ValueError):

3833 array.__reduce_ex__(5)

3834

3835 def test_record_array_with_object_dtype(self):

3836 my_object = object()

3837

3838 arr_with_object = np.array(

3839 [(my_object, 1, 2.0)],

3840 dtype=[('a', object), ('b', int), ('c', float)])

3841 arr_without_object = np.array(

3842 [('xxx', 1, 2.0)],

3843 dtype=[('a', str), ('b', int), ('c', float)])

3844

3845 for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):

3846 depickled_arr_with_object = pickle.loads(

3847 pickle.dumps(arr_with_object, protocol=proto))

3848 depickled_arr_without_object = pickle.loads(

3849 pickle.dumps(arr_without_object, protocol=proto))

3850

3851 assert_equal(arr_with_object.dtype,

3852 depickled_arr_with_object.dtype)

3853 assert_equal(arr_without_object.dtype,

3854 depickled_arr_without_object.dtype)

3855

3856 @pytest.mark.skipif(pickle.HIGHEST_PROTOCOL < 5,

3857 reason="requires pickle protocol 5")

3858 def test_f_contiguous_array(self):

3859 f_contiguous_array = np.array([[1, 2, 3], [4, 5, 6]], order='F')

3860 buffers = []

3861

3862 # When using pickle protocol 5, Fortran-contiguous arrays can be

3863 # serialized using out-of-band buffers

3864 bytes_string = pickle.dumps(f_contiguous_array, protocol=5,

3865 buffer_callback=buffers.append)

3866

3867 assert len(buffers) > 0

3868

3869 depickled_f_contiguous_array = pickle.loads(bytes_string,

3870 buffers=buffers)

3871

3872 assert_equal(f_contiguous_array, depickled_f_contiguous_array)

3873

3874 def test_non_contiguous_array(self):

3875 non_contiguous_array = np.arange(12).reshape(3, 4)[:, :2]

3876 assert not non_contiguous_array.flags.c_contiguous

3877 assert not non_contiguous_array.flags.f_contiguous

3878

3879 # make sure non-contiguous arrays can be pickled-depickled

3880 # using any protocol

3881 for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):

3882 depickled_non_contiguous_array = pickle.loads(

3883 pickle.dumps(non_contiguous_array, protocol=proto))

3884

3885 assert_equal(non_contiguous_array, depickled_non_contiguous_array)

3886

3887 def test_roundtrip(self):

3888 for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):

3889 carray = np.array([[2, 9], [7, 0], [3, 8]])

3890 DATA = [

3891 carray,

3892 np.transpose(carray),

3893 np.array([('xxx', 1, 2.0)], dtype=[('a', (str, 3)), ('b', int),

3894 ('c', float)])

3895 ]

3896

3897 refs = [weakref.ref(a) for a in DATA]

3898 for a in DATA:

3899 assert_equal(

3900 a, pickle.loads(pickle.dumps(a, protocol=proto)),

3901 err_msg="%r" % a)

3902 del a, DATA, carray

3903 break_cycles()

3904 # check for reference leaks (gh-12793)

3905 for ref in refs:

3906 assert ref() is None

3907

3908 def _loads(self, obj):

3909 return pickle.loads(obj, encoding='latin1')

3910

3911 # version 0 pickles, using protocol=2 to pickle

3912 # version 0 doesn't have a version field

3913 def test_version0_int8(self):

3914 s = b'\x80\x02cnumpy.core._internal\n_reconstruct\nq\x01cnumpy\nndarray\nq\x02K\x00\x85U\x01b\x87Rq\x03(K\x04\x85cnumpy\ndtype\nq\x04U\x02i1K\x00K\x01\x87Rq\x05(U\x01|NNJ\xff\xff\xff\xffJ\xff\xff\xff\xfftb\x89U\x04\x01\x02\x03\x04tb.'

3915 a = np.array([1, 2, 3, 4], dtype=np.int8)

3916 p = self._loads(s)

3917 assert_equal(a, p)

3918

3919 def test_version0_float32(self):

3920 s = b'\x80\x02cnumpy.core._internal\n_reconstruct\nq\x01cnumpy\nndarray\nq\x02K\x00\x85U\x01b\x87Rq\x03(K\x04\x85cnumpy\ndtype\nq\x04U\x02f4K\x00K\x01\x87Rq\x05(U\x01<NNJ\xff\xff\xff\xffJ\xff\xff\xff\xfftb\x89U\x10\x00\x00\x80?\x00\x00\x00@\x00\x00@@\x00\x00\x80@tb.'

3921 a = np.array([1.0, 2.0, 3.0, 4.0], dtype=np.float32)

3922 p = self._loads(s)

3923 assert_equal(a, p)

3924

3925 def test_version0_object(self):

3926 s = b'\x80\x02cnumpy.core._internal\n_reconstruct\nq\x01cnumpy\nndarray\nq\x02K\x00\x85U\x01b\x87Rq\x03(K\x02\x85cnumpy\ndtype\nq\x04U\x02O8K\x00K\x01\x87Rq\x05(U\x01|NNJ\xff\xff\xff\xffJ\xff\xff\xff\xfftb\x89]q\x06(}q\x07U\x01aK\x01s}q\x08U\x01bK\x02setb.'

3927 a = np.array([{'a': 1}, {'b': 2}])

3928 p = self._loads(s)

3929 assert_equal(a, p)

3930

3931 # version 1 pickles, using protocol=2 to pickle

3932 def test_version1_int8(self):

3933 s = b'\x80\x02cnumpy.core._internal\n_reconstruct\nq\x01cnumpy\nndarray\nq\x02K\x00\x85U\x01b\x87Rq\x03(K\x01K\x04\x85cnumpy\ndtype\nq\x04U\x02i1K\x00K\x01\x87Rq\x05(K\x01U\x01|NNJ\xff\xff\xff\xffJ\xff\xff\xff\xfftb\x89U\x04\x01\x02\x03\x04tb.'

3934 a = np.array([1, 2, 3, 4], dtype=np.int8)

3935 p = self._loads(s)

3936 assert_equal(a, p)

3937

3938 def test_version1_float32(self):

3939 s = b'\x80\x02cnumpy.core._internal\n_reconstruct\nq\x01cnumpy\nndarray\nq\x02K\x00\x85U\x01b\x87Rq\x03(K\x01K\x04\x85cnumpy\ndtype\nq\x04U\x02f4K\x00K\x01\x87Rq\x05(K\x01U\x01<NNJ\xff\xff\xff\xffJ\xff\xff\xff\xfftb\x89U\x10\x00\x00\x80?\x00\x00\x00@\x00\x00@@\x00\x00\x80@tb.'

3940 a = np.array([1.0, 2.0, 3.0, 4.0], dtype=np.float32)

3941 p = self._loads(s)

3942 assert_equal(a, p)

3943

3944 def test_version1_object(self):

3945 s = b'\x80\x02cnumpy.core._internal\n_reconstruct\nq\x01cnumpy\nndarray\nq\x02K\x00\x85U\x01b\x87Rq\x03(K\x01K\x02\x85cnumpy\ndtype\nq\x04U\x02O8K\x00K\x01\x87Rq\x05(K\x01U\x01|NNJ\xff\xff\xff\xffJ\xff\xff\xff\xfftb\x89]q\x06(}q\x07U\x01aK\x01s}q\x08U\x01bK\x02setb.'

3946 a = np.array([{'a': 1}, {'b': 2}])

3947 p = self._loads(s)

3948 assert_equal(a, p)

3949

3950 def test_subarray_int_shape(self):

3951 s = b"cnumpy.core.multiarray\n_reconstruct\np0\n(cnumpy\nndarray\np1\n(I0\ntp2\nS'b'\np3\ntp4\nRp5\n(I1\n(I1\ntp6\ncnumpy\ndtype\np7\n(S'V6'\np8\nI0\nI1\ntp9\nRp10\n(I3\nS'|'\np11\nN(S'a'\np12\ng3\ntp13\n(dp14\ng12\n(g7\n(S'V4'\np15\nI0\nI1\ntp16\nRp17\n(I3\nS'|'\np18\n(g7\n(S'i1'\np19\nI0\nI1\ntp20\nRp21\n(I3\nS'|'\np22\nNNNI-1\nI-1\nI0\ntp23\nb(I2\nI2\ntp24\ntp25\nNNI4\nI1\nI0\ntp26\nbI0\ntp27\nsg3\n(g7\n(S'V2'\np28\nI0\nI1\ntp29\nRp30\n(I3\nS'|'\np31\n(g21\nI2\ntp32\nNNI2\nI1\nI0\ntp33\nbI4\ntp34\nsI6\nI1\nI0\ntp35\nbI00\nS'\\x01\\x01\\x01\\x01\\x01\\x02'\np36\ntp37\nb."

3952 a = np.array([(1, (1, 2))], dtype=[('a', 'i1', (2, 2)), ('b', 'i1', 2)])

3953 p = self._loads(s)

3954 assert_equal(a, p)

3955

3956 def test_datetime64_byteorder(self):

3957 original = np.array([['2015-02-24T00:00:00.000000000']], dtype='datetime64[ns]')

3958

3959 original_byte_reversed = original.copy(order='K')

3960 original_byte_reversed.dtype = original_byte_reversed.dtype.newbyteorder('S')

3961 original_byte_reversed.byteswap(inplace=True)

3962

3963 new = pickle.loads(pickle.dumps(original_byte_reversed))