19a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 29a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# The ndarray object from _testbuffer.c is a complete implementation of 39a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# a PEP-3118 buffer provider. It is independent from NumPy's ndarray 49a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# and the tests don't require NumPy. 59a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 69a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# If NumPy is present, some tests check both ndarray implementations 79a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# against each other. 89a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 99a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Most ndarray tests also check that memoryview(ndarray) behaves in 109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# the same way as the original. Thus, a substantial part of the 119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# memoryview tests is now in this module. 129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1431084ba52856329b972b84299b438bf5b73be292Antoine Pitrouimport contextlib 159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahimport unittest 169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfrom test import support 179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfrom itertools import permutations, product 189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfrom random import randrange, sample, choice 199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahimport warnings 209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahimport sys, array, io 219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfrom decimal import Decimal 229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfrom fractions import Fraction 239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahtry: 259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah from _testbuffer import * 269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahexcept ImportError: 279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndarray = None 289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahtry: 309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah import struct 319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahexcept ImportError: 329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct = None 339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahtry: 3506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan import ctypes 3606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlanexcept ImportError: 3706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ctypes = None 3806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 3906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlantry: 409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah with warnings.catch_warnings(): 419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah from numpy import ndarray as numpy_array 429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahexcept ImportError: 439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah numpy_array = None 449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 469a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahSHORT_TEST = True 479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Random lists by format specifier 519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Native format chars and their ranges. 549a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahNATIVE = { 559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '?':0, 'c':0, 'b':0, 'B':0, 569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'h':0, 'H':0, 'i':0, 'I':0, 579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'l':0, 'L':0, 'n':0, 'N':0, 589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'f':0, 'd':0, 'P':0 599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah} 609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 617d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah# NumPy does not have 'n' or 'N': 627d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krahif numpy_array: 637d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah del NATIVE['n'] 647d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah del NATIVE['N'] 657d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahif struct: 679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Add "qQ" if present in native mode. 699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct.pack('Q', 2**64-1) 709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah NATIVE['q'] = 0 719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah NATIVE['Q'] = 0 729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except struct.error: 739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah pass 749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Standard format chars and their ranges. 769a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahSTANDARD = { 779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '?':(0, 2), 'c':(0, 1<<8), 789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'b':(-(1<<7), 1<<7), 'B':(0, 1<<8), 799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'h':(-(1<<15), 1<<15), 'H':(0, 1<<16), 809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'i':(-(1<<31), 1<<31), 'I':(0, 1<<32), 819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'l':(-(1<<31), 1<<31), 'L':(0, 1<<32), 829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'q':(-(1<<63), 1<<63), 'Q':(0, 1<<64), 839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'f':(-(1<<63), 1<<63), 'd':(-(1<<1023), 1<<1023) 849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah} 859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef native_type_range(fmt): 879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return range of a native type.""" 889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt == 'c': 899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lh = (0, 256) 909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif fmt == '?': 919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lh = (0, 2) 929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif fmt == 'f': 939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lh = (-(1<<63), 1<<63) 949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif fmt == 'd': 959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lh = (-(1<<1023), 1<<1023) 969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for exp in (128, 127, 64, 63, 32, 31, 16, 15, 8, 7): 989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct.pack(fmt, (1<<exp)-1) 1009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah break 1019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except struct.error: 1029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah pass 1039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lh = (-(1<<exp), 1<<exp) if exp & 1 else (0, 1<<exp) 1049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lh 1059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict = { 1079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '':NATIVE, 1089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '@':NATIVE, 1099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '<':STANDARD, 1109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '>':STANDARD, 1119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '=':STANDARD, 1129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '!':STANDARD 1139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah} 1149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahif struct: 1169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 1179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmtdict['@'][fmt] = native_type_range(fmt) 1189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1199a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahMEMORYVIEW = NATIVE.copy() 1209a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahARRAY = NATIVE.copy() 1219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfor k in NATIVE: 1229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not k in "bBhHiIlLfd": 1239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del ARRAY[k] 1249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1259a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahBYTEFMT = NATIVE.copy() 1269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfor k in NATIVE: 1279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not k in "Bbc": 1289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del BYTEFMT[k] 1299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict['m'] = MEMORYVIEW 1319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict['@m'] = MEMORYVIEW 1329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict['a'] = ARRAY 1339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict['b'] = BYTEFMT 1349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahfmtdict['@b'] = BYTEFMT 1359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Capabilities of the test objects: 1379a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahMODE = 0 1389a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahMULT = 1 1399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahcap = { # format chars # multiplier 1409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'ndarray': (['', '@', '<', '>', '=', '!'], ['', '1', '2', '3']), 1419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'array': (['a'], ['']), 1429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'numpy': ([''], ['']), 1439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'memoryview': (['@m', 'm'], ['']), 1449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'bytefmt': (['@b', 'b'], ['']), 1459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah} 1469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef randrange_fmt(mode, char, obj): 1489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return random item for a type specified by a mode and a single 1499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format character.""" 1509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = randrange(*fmtdict[mode][char]) 1519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if char == 'c': 15274a49ac3f5ac3c7a09c691db4888c981a0cb3232Serhiy Storchaka x = bytes([x]) 15374a49ac3f5ac3c7a09c691db4888c981a0cb3232Serhiy Storchaka if obj == 'numpy' and x == b'\x00': 15474a49ac3f5ac3c7a09c691db4888c981a0cb3232Serhiy Storchaka # http://projects.scipy.org/numpy/ticket/1925 15574a49ac3f5ac3c7a09c691db4888c981a0cb3232Serhiy Storchaka x = b'\x01' 1569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if char == '?': 1579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = bool(x) 1589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if char == 'f' or char == 'd': 1599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = struct.pack(char, x) 1609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = struct.unpack(char, x)[0] 1619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return x 1629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef gen_item(fmt, obj): 1649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return single random item.""" 1659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mode, chars = fmt.split('#') 1669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = [] 1679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for c in chars: 1689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x.append(randrange_fmt(mode, c, obj)) 1699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return x[0] if len(x) == 1 else tuple(x) 1709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef gen_items(n, fmt, obj): 1729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return a list of random items (or a scalar).""" 1739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if n == 0: 1749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return gen_item(fmt, obj) 1759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = [0] * n 1769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(n): 1779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst[i] = gen_item(fmt, obj) 1789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 1799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef struct_items(n, obj): 1819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mode = choice(cap[obj][MODE]) 1829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xfmt = mode + '#' 1839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt = mode.strip('amb') 1849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nmemb = randrange(2, 10) # number of struct members 1859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(nmemb): 1869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah char = choice(tuple(fmtdict[mode])) 1879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah multiplier = choice(cap[obj][MULT]) 1889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xfmt += (char * int(multiplier if multiplier else 1)) 1899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt += (multiplier + char) 1909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = gen_items(n, xfmt, obj) 1919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah item = gen_item(xfmt, obj) 1929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return fmt, items, item 1939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef randitems(n, obj='ndarray', mode=None, char=None): 1959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return random format, items, item.""" 1969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if mode is None: 1979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mode = choice(cap[obj][MODE]) 1989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if char is None: 1999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah char = choice(tuple(fmtdict[mode])) 2009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah multiplier = choice(cap[obj][MULT]) 2019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt = mode + '#' + char * int(multiplier if multiplier else 1) 2029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = gen_items(n, fmt, obj) 2039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah item = gen_item(fmt, obj) 2049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt = mode.strip('amb') + multiplier + char 2059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return fmt, items, item 2069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef iter_mode(n, obj='ndarray'): 2089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Iterate through supported mode/char combinations.""" 2099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for mode in cap[obj][MODE]: 2109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for char in fmtdict[mode]: 2119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield randitems(n, obj, mode, char) 2129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef iter_format(nitems, testobj='ndarray'): 2149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Yield (format, items, item) for all possible modes and format 2159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah characters plus one random compound format string.""" 2169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for t in iter_mode(nitems, testobj): 2179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield t 2189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if testobj != 'ndarray': 219bb6c0aaebfbeb9ab13886e261df904c9c12853b9Raymond Hettinger return 2209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield struct_items(nitems, testobj) 2219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef is_byte_format(fmt): 2249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 'c' in fmt or 'b' in fmt or 'B' in fmt 2259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef is_memoryview_format(fmt): 2279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """format suitable for memoryview""" 2289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = len(fmt) 2299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ((x == 1 or (x == 2 and fmt[0] == '@')) and 2309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt[x-1] in MEMORYVIEW) 2319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2329a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahNON_BYTE_FORMAT = [c for c in fmtdict['@'] if not is_byte_format(c)] 2339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 2369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Multi-dimensional tolist(), slicing and slice assignments 2379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 2389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef atomp(lst): 2409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Tuple items (representing structs) are regarded as atoms.""" 2419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return not isinstance(lst, list) 2429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef listp(lst): 2449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return isinstance(lst, list) 2459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef prod(lst): 2479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Product of list elements.""" 2489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if len(lst) == 0: 2499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 0 2509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = lst[0] 2519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for v in lst[1:]: 2529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x *= v 2539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return x 2549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef strides_from_shape(ndim, shape, itemsize, layout): 2569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Calculate strides of a contiguous array. Layout is 'C' or 2579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'F' (Fortran).""" 2589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ndim == 0: 2599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return () 2609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if layout == 'C': 2619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = list(shape[1:]) + [itemsize] 2629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(ndim-2, -1, -1): 2639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[i] *= strides[i+1] 2649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 2659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = [itemsize] + list(shape[:-1]) 2669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(1, ndim): 2679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[i] *= strides[i-1] 2689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return strides 2699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef _ca(items, s): 2719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Convert flat item list to the nested list representation of a 2729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah multidimensional C array with shape 's'.""" 2739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(items): 2749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return items 2759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if len(s) == 0: 2769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return items[0] 2779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = [0] * s[0] 2789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stride = len(items) // s[0] if s[0] else 0 2799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(s[0]): 2809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah start = i*stride 2819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst[i] = _ca(items[start:start+stride], s[1:]) 2829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 2839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef _fa(items, s): 2859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Convert flat item list to the nested list representation of a 2869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah multidimensional Fortran array with shape 's'.""" 2879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(items): 2889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return items 2899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if len(s) == 0: 2909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return items[0] 2919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = [0] * s[0] 2929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stride = s[0] 2939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(s[0]): 2949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst[i] = _fa(items[i::stride], s[1:]) 2959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 2969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef carray(items, shape): 2989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if listp(items) and not 0 in shape and prod(shape) != len(items): 2999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah raise ValueError("prod(shape) != len(items)") 3009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return _ca(items, shape) 3019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef farray(items, shape): 3039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if listp(items) and not 0 in shape and prod(shape) != len(items): 3049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah raise ValueError("prod(shape) != len(items)") 3059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return _fa(items, shape) 3069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef indices(shape): 3089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate all possible tuples of indices.""" 3099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah iterables = [range(v) for v in shape] 3109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return product(*iterables) 3119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef getindex(ndim, ind, strides): 3139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Convert multi-dimensional index to the position in the flat list.""" 3149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ret = 0 3159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(ndim): 3169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ret += strides[i] * ind[i] 3179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ret 3189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef transpose(src, shape): 3209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Transpose flat item list that is regarded as a multi-dimensional 3219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah matrix defined by shape: dest...[k][j][i] = src[i][j][k]... """ 3229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not shape: 3239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return src 3249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 3259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sstrides = strides_from_shape(ndim, shape, 1, 'C') 3269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dstrides = strides_from_shape(ndim, shape[::-1], 1, 'C') 3279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dest = [0] * len(src) 3289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for ind in indices(shape): 3299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fr = getindex(ndim, ind, sstrides) 3309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah to = getindex(ndim, ind[::-1], dstrides) 3319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dest[to] = src[fr] 3329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return dest 3339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef _flatten(lst): 3359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """flatten list""" 3369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if lst == []: 3379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 3389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(lst): 3399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return [lst] 3409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return _flatten(lst[0]) + _flatten(lst[1:]) 3419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef flatten(lst): 3439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """flatten list or return scalar""" 3449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(lst): # scalar 3459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 3469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return _flatten(lst) 3479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef slice_shape(lst, slices): 3499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Get the shape of lst after slicing: slices is a list of slice 3509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah objects.""" 3519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(lst): 3529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return [] 3539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return [len(lst[slices[0]])] + slice_shape(lst[0], slices[1:]) 3549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef multislice(lst, slices): 3569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Multi-dimensional slicing: slices is a list of slice objects.""" 3579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(lst): 3589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 3599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return [multislice(sublst, slices[1:]) for sublst in lst[slices[0]]] 3609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef m_assign(llst, rlst, lslices, rslices): 3629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Multi-dimensional slice assignment: llst and rlst are the operands, 3639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices and rslices are lists of slice objects. llst and rlst must 3649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah have the same structure. 3659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah For a two-dimensional example, this is not implemented in Python: 3679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah llst[0:3:2, 0:3:2] = rlst[1:3:1, 1:3:1] 3699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah Instead we write: 3719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices = [slice(0,3,2), slice(0,3,2)] 3739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rslices = [slice(1,3,1), slice(1,3,1)] 3749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah multislice_assign(llst, rlst, lslices, rslices) 3759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """ 3769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if atomp(rlst): 3779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return rlst 3789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rlst = [m_assign(l, r, lslices[1:], rslices[1:]) 3799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for l, r in zip(llst[lslices[0]], rlst[rslices[0]])] 3809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah llst[lslices[0]] = rlst 3819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return llst 3829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef cmp_structure(llst, rlst, lslices, rslices): 3849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Compare the structure of llst[lslices] and rlst[rslices].""" 3859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lshape = slice_shape(llst, lslices) 3869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rshape = slice_shape(rlst, rslices) 3879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if (len(lshape) != len(rshape)): 3889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return -1 3899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(len(lshape)): 3909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if lshape[i] != rshape[i]: 3919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return -1 3929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if lshape[i] == 0: 3939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 0 3949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 0 3959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 3969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef multislice_assign(llst, rlst, lslices, rslices): 3979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return llst after assigning: llst[lslices] = rlst[rslices]""" 3989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if cmp_structure(llst, rlst, lslices, rslices) < 0: 3999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah raise ValueError("lvalue and rvalue have different structures") 4009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return m_assign(llst, rlst, lslices, rslices) 4019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 4049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Random structures 4059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 4069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# PEP-3118 is very permissive with respect to the contents of a 4099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Py_buffer. In particular: 4109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# - shape can be zero 4129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# - strides can be any integer, including zero 4139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# - offset can point to any location in the underlying 4149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# memory block, provided that it is a multiple of 4159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# itemsize. 4169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# The functions in this section test and verify random structures 4189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# in full generality. A structure is valid iff it fits in the 4199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# underlying memory block. 4209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# The structure 't' (short for 'tuple') is fully defined by: 4229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# t = (memlen, itemsize, ndim, shape, strides, offset) 4249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# 4259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef verify_structure(memlen, itemsize, ndim, shape, strides, offset): 4279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Verify that the parameters represent a valid array within 4289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah the bounds of the allocated memory: 4299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah char *mem: start of the physical memory block 4309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen: length of the physical memory block 4319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset: (char *)buf - mem 4329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """ 4339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if offset % itemsize: 4349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return False 4359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if offset < 0 or offset+itemsize > memlen: 4369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return False 4379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if any(v % itemsize for v in strides): 4389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return False 4399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ndim <= 0: 4419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ndim == 0 and not shape and not strides 4429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 0 in shape: 4439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return True 4449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah imin = sum(strides[j]*(shape[j]-1) for j in range(ndim) 4469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[j] <= 0) 4479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah imax = sum(strides[j]*(shape[j]-1) for j in range(ndim) 4489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[j] > 0) 4499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 0 <= offset+imin and offset+imax+itemsize <= memlen 4519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef get_item(lst, indices): 4539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in indices: 4549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = lst[i] 4559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lst 4569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef memory_index(indices, t): 4589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Location of an item in the underlying memory.""" 4599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen, itemsize, ndim, shape, strides, offset = t 4609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah p = offset 4619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(ndim): 4629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah p += strides[i]*indices[i] 4639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return p 4649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef is_overlapping(t): 4669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """The structure 't' is overlapping if at least one memory location 4679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah is visited twice while iterating through all possible tuples of 4689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah indices.""" 4699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen, itemsize, ndim, shape, strides, offset = t 4709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah visited = 1<<memlen 4719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for ind in indices(shape): 4729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah i = memory_index(ind, t) 4739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bit = 1<<i 4749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if visited & bit: 4759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return True 4769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah visited |= bit 4779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return False 4789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rand_structure(itemsize, valid, maxdim=5, maxshape=16, shape=()): 4809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return random structure: 4819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (memlen, itemsize, ndim, shape, strides, offset) 4829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah If 'valid' is true, the returned structure is valid, otherwise invalid. 4839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah If 'shape' is given, use that instead of creating a random shape. 4849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """ 4859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not shape: 4869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = randrange(maxdim+1) 4879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if (ndim == 0): 4889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if valid: 4899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return itemsize, itemsize, ndim, (), (), 0 4909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 4919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = randrange(1, 16+1) 4929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen = nitems * itemsize 4939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = -itemsize if randrange(2) == 0 else memlen 4949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return memlen, itemsize, ndim, (), (), offset 4959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 4969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 2 4979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = randrange(100) 4989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if n >= 95 and valid: 4999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 0 5009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif n >= 90: 5019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 1 5029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = [0] * ndim 5039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(ndim): 5059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape[i] = randrange(minshape, maxshape+1) 5069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 5079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 5089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxstride = 5 5109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = randrange(100) 5119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah zero_stride = True if n >= 95 and n & 1 else False 5129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = [0] * ndim 5149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[ndim-1] = itemsize * randrange(-maxstride, maxstride+1) 5159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not zero_stride and strides[ndim-1] == 0: 5169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[ndim-1] = itemsize 5179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(ndim-2, -1, -1): 5199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxstride *= shape[i+1] if shape[i+1] else 1 5209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if zero_stride: 5219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[i] = itemsize * randrange(-maxstride, maxstride+1) 5229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 5239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides[i] = ((1,-1)[randrange(2)] * 5249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize * randrange(1, maxstride+1)) 5259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah imin = imax = 0 5279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not 0 in shape: 5289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah imin = sum(strides[j]*(shape[j]-1) for j in range(ndim) 5299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[j] <= 0) 5309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah imax = sum(strides[j]*(shape[j]-1) for j in range(ndim) 5319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[j] > 0) 5329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = imax - imin 5349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if valid: 5359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = -imin * itemsize 5369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen = offset + (imax+1) * itemsize 5379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 5389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen = (-imin + imax) * itemsize 5399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = -imin-itemsize if randrange(2) == 0 else memlen 5409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return memlen, itemsize, ndim, shape, strides, offset 5419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef randslice_from_slicelen(slicelen, listlen): 5439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Create a random slice of len slicelen that fits into listlen.""" 5449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxstart = listlen - slicelen 5459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah start = randrange(maxstart+1) 5469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxstep = (listlen - start) // slicelen if slicelen else 1 5479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah step = randrange(1, maxstep+1) 5489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stop = start + slicelen * step 5499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah s = slice(start, stop, step) 5509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah _, _, _, control = slice_indices(s, listlen) 5519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if control != slicelen: 5529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah raise RuntimeError 5539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return s 5549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef randslice_from_shape(ndim, shape): 5569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Create two sets of slices for an array x with shape 'shape' 5579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah such that shapeof(x[lslices]) == shapeof(x[rslices]).""" 5589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices = [0] * ndim 5599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rslices = [0] * ndim 5609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for n in range(ndim): 5619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah l = shape[n] 5629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah slicelen = randrange(1, l+1) if l > 0 else 0 5639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices[n] = randslice_from_slicelen(slicelen, l) 5649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rslices[n] = randslice_from_slicelen(slicelen, l) 5659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return tuple(lslices), tuple(rslices) 5669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rand_aligned_slices(maxdim=5, maxshape=16): 5689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Create (lshape, rshape, tuple(lslices), tuple(rslices)) such that 5699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shapeof(x[lslices]) == shapeof(y[rslices]), where x is an array 5709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah with shape 'lshape' and y is an array with shape 'rshape'.""" 5719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = randrange(1, maxdim+1) 5729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 2 5739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = randrange(100) 5749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if n >= 95: 5759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 0 5769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif n >= 90: 5779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 1 5789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah all_random = True if randrange(100) >= 80 else False 5799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lshape = [0]*ndim; rshape = [0]*ndim 5809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices = [0]*ndim; rslices = [0]*ndim 5819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for n in range(ndim): 5839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah small = randrange(minshape, maxshape+1) 5849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah big = randrange(minshape, maxshape+1) 5859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if big < small: 5869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah big, small = small, big 5879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Create a slice that fits the smaller value. 5899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if all_random: 5909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah start = randrange(-small, small+1) 5919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stop = randrange(-small, small+1) 5929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah step = (1,-1)[randrange(2)] * randrange(1, small+2) 5939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah s_small = slice(start, stop, step) 5949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah _, _, _, slicelen = slice_indices(s_small, small) 5959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 5969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah slicelen = randrange(1, small+1) if small > 0 else 0 5979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah s_small = randslice_from_slicelen(slicelen, small) 5989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 5999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Create a slice of the same length for the bigger value. 6009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah s_big = randslice_from_slicelen(slicelen, big) 6019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if randrange(2) == 0: 6029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rshape[n], lshape[n] = big, small 6039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rslices[n], lslices[n] = s_big, s_small 6049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 6059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rshape[n], lshape[n] = small, big 6069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rslices[n], lslices[n] = s_small, s_big 6079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return lshape, rshape, tuple(lslices), tuple(rslices) 6099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef randitems_from_structure(fmt, t): 6119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return a list of random items for structure 't' with format 6129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'fmtchar'.""" 6139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen, itemsize, _, _, _, _ = t 6149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return gen_items(memlen//itemsize, '#'+fmt, 'numpy') 6159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef ndarray_from_structure(items, fmt, t, flags=0): 6179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return ndarray from the tuple returned by rand_structure()""" 6189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen, itemsize, ndim, shape, strides, offset = t 6199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ndarray(items, shape=shape, strides=strides, format=fmt, 6209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset=offset, flags=ND_WRITABLE|flags) 6219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef numpy_array_from_structure(items, fmt, t): 6239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Return numpy_array from the tuple returned by rand_structure()""" 6249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah memlen, itemsize, ndim, shape, strides, offset = t 6259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf = bytearray(memlen) 6269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for j, v in enumerate(items): 6279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct.pack_into(fmt, buf, j*itemsize, v) 6289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return numpy_array(buffer=buf, shape=shape, strides=strides, 6299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dtype=fmt, offset=offset) 6309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 6339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# memoryview casts 6349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 6359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef cast_items(exporter, fmt, itemsize, shape=None): 6379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Interpret the raw memory of 'exporter' as a list of items with 6389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size 'itemsize'. If shape=None, the new structure is assumed to 6399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah be 1-D with n * itemsize = bytelen. If shape is given, the usual 6409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah constraint for contiguous arrays prod(shape) * itemsize = bytelen 6419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah applies. On success, return (items, shape). If the constraints 6429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah cannot be met, return (None, None). If a chunk of bytes is interpreted 6439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah as NaN as a result of float conversion, return ('nan', None).""" 6449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bytelen = exporter.nbytes 6459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if shape: 6469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if prod(shape) * itemsize != bytelen: 6479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return None, shape 6489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif shape == []: 6499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if exporter.ndim == 0 or itemsize != bytelen: 6509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return None, shape 6519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 6529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n, r = divmod(bytelen, itemsize) 6539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = [n] 6549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if r != 0: 6559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return None, shape 6569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mem = exporter.tobytes() 6589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah byteitems = [mem[i:i+itemsize] for i in range(0, len(mem), itemsize)] 6599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [] 6619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for v in byteitems: 6629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah item = struct.unpack(fmt, v)[0] 6639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if item != item: 6649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 'nan', shape 6659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items.append(item) 6669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return (items, shape) if shape != [] else (items[0], shape) 6689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef gencastshapes(): 6709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate shapes to test casting.""" 6719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for n in range(32): 6729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield [n] 6739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = randrange(4, 6) 6749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 1 if randrange(100) > 80 else 2 6759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield [randrange(minshape, 5) for _ in range(ndim)] 6769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = randrange(2, 4) 6779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minshape = 1 if randrange(100) > 80 else 2 6789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield [randrange(minshape, 5) for _ in range(ndim)] 6799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 6829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# Actual tests 6839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah# ====================================================================== 6849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef genslices(n): 6869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate all possible slices for a single dimension.""" 6879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return product(range(-n, n+1), range(-n, n+1), range(-n, n+1)) 6889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef genslices_ndim(ndim, shape): 6909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate all possible slice tuples for 'shape'.""" 6919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah iterables = [genslices(shape[n]) for n in range(ndim)] 6929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return product(*iterables) 6939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 6949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rslice(n, allow_empty=False): 6959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate random slice for a single dimension of length n. 6969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah If zero=True, the slices may be empty, otherwise they will 6979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah be non-empty.""" 6989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah minlen = 0 if allow_empty or n == 0 else 1 6999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah slicelen = randrange(minlen, n+1) 7009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return randslice_from_slicelen(slicelen, n) 7019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rslices(n, allow_empty=False): 7039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate random slices for a single dimension.""" 7049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(5): 7059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield rslice(n, allow_empty) 7069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rslices_ndim(ndim, shape, iterations=5): 7089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Generate random slice tuples for 'shape'.""" 7099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-empty slices 7109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(iterations): 7119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield tuple(rslice(shape[n]) for n in range(ndim)) 7129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # possibly empty slices 7139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(iterations): 7149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield tuple(rslice(shape[n], allow_empty=True) for n in range(ndim)) 7159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid slices 7169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield tuple(slice(0,1,0) for _ in range(ndim)) 7179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef rpermutation(iterable, r=None): 7199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah pool = tuple(iterable) 7209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah r = len(pool) if r is None else r 7219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yield tuple(sample(pool, r)) 7229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahdef ndarray_print(nd): 7249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah """Print ndarray for debugging.""" 7259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 7269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd.tolist() 7279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except (TypeError, NotImplementedError): 7289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd.tobytes() 7299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if isinstance(nd, ndarray): 7309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = nd.offset 7319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags = nd.flags 7329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 7339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = 'unknown' 7349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags = 'unknown' 7359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah print("ndarray(%s, shape=%s, strides=%s, suboffsets=%s, offset=%s, " 7369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah "format='%s', itemsize=%s, flags=%s)" % 7379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (x, nd.shape, nd.strides, nd.suboffsets, offset, 7389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.format, nd.itemsize, flags)) 7399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sys.stdout.flush() 7409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7429a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahITERATIONS = 100 7439a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahMAXDIM = 5 7449a2d99e28a5c2989b2db4023acae4f550885f2efStefan KrahMAXSHAPE = 10 7459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahif SHORT_TEST: 7479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ITERATIONS = 10 7489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah MAXDIM = 3 7499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah MAXSHAPE = 4 7509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah genslices = rslices 7519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah genslices_ndim = rslices_ndim 7529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah permutations = rpermutation 7539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah@unittest.skipUnless(struct, 'struct module required for this test.') 7569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah@unittest.skipUnless(ndarray, 'ndarray object required for this test') 7579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahclass TestBufferProtocol(unittest.TestCase): 7589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def setUp(self): 7605d953184a6fae25bf27e769c90b419d9b2aa1af9Stefan Krah # The suboffsets tests need sizeof(void *). 7615d953184a6fae25bf27e769c90b419d9b2aa1af9Stefan Krah self.sizeof_void_p = get_sizeof_void_p() 7629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def verify(self, result, obj=-1, 7649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize={1}, fmt=-1, readonly={1}, 7659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim={1}, shape=-1, strides=-1, 7669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=-1, sliced=False, cast=False): 7679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Verify buffer contents against expected values. Default values 7689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # are deliberately initialized to invalid types. 7699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if shape: 7709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected_len = prod(shape)*itemsize 7719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 7729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not fmt: # array has been implicitly cast to unsigned bytes 7739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected_len = len(lst) 7749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: # ndim = 0 7759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected_len = itemsize 7769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Reconstruct suboffsets from strides. Support for slicing 7789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # could be added, but is currently only needed for test_getbuf(). 7799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah suboffsets = () 7809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if result.suboffsets: 7819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertGreater(ndim, 0) 7829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah suboffset0 = 0 7849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for n in range(1, ndim): 7859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if shape[n] == 0: 7869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah break 7879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[n] <= 0: 7889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah suboffset0 += -strides[n] * (shape[n]-1) 7899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah suboffsets = [suboffset0] + [-1 for v in range(ndim-1)] 7919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Not correct if slicing has occurred in the first dimension. 7939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stride0 = self.sizeof_void_p 7949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides[0] < 0: 7959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah stride0 = -stride0 7969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = [stride0] + list(strides[1:]) 7979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 7989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(result.obj, obj) 7999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.nbytes, expected_len) 8009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.itemsize, itemsize) 8019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.format, fmt) 8029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.readonly, readonly) 8039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.ndim, ndim) 8049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.shape, tuple(shape)) 8059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not (sliced and suboffsets): 8069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.strides, tuple(strides)) 8079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.suboffsets, tuple(suboffsets)) 8089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if isinstance(result, ndarray) or is_memoryview_format(fmt): 8109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rep = result.tolist() if fmt else result.tobytes() 8119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(rep, lst) 8129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not fmt: # array has been cast to unsigned bytes, 8149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return # the remaining tests won't work. 8159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyBuffer_GetPointer() is the definition how to access an item. 8179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # If PyBuffer_GetPointer(indices) is correct for all possible 8189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # combinations of indices, the buffer is correct. 8199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # 8209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Also test tobytes() against the flattened 'lst', with all items 8219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # packed to bytes. 8229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not cast: # casts chop up 'lst' in different ways 8239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytearray() 8249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf_err = None 8259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for ind in indices(shape): 8269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 8279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah item1 = get_pointer(result, ind) 8289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah item2 = get_item(lst, ind) 8299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if isinstance(item2, tuple): 8309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = struct.pack(fmt, *item2) 8319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 8329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = struct.pack(fmt, item2) 8339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b.extend(x) 8349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except BufferError: 8359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf_err = True # re-exporter does not provide full buffer 8369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah break 8379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(item1, item2) 8389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not buf_err: 8409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # test tobytes() 8419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(result.tobytes(), b) 8429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8430ce5b6e2688ddf342780b663a095b3e0c9f5cc72Stefan Krah # test hex() 8440ce5b6e2688ddf342780b663a095b3e0c9f5cc72Stefan Krah m = memoryview(result) 8450ce5b6e2688ddf342780b663a095b3e0c9f5cc72Stefan Krah h = "".join("%02x" % c for c in b) 8460ce5b6e2688ddf342780b663a095b3e0c9f5cc72Stefan Krah self.assertEqual(m.hex(), h) 8470ce5b6e2688ddf342780b663a095b3e0c9f5cc72Stefan Krah 8489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # lst := expected multi-dimensional logical representation 8499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flatten(lst) := elements in C-order 8509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ff = fmt if fmt else 'B' 8519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flattened = flatten(lst) 8529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Rules for 'A': if the array is already contiguous, return 8549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # the array unaltered. Otherwise, return a contiguous 'C' 8559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # representation. 8569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 8579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected = result 8589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if order == 'F': 8599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_contiguous(result, 'A') or \ 8609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah is_contiguous(result, 'C'): 8619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # For constructing the ndarray, convert the 8629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flattened logical representation to Fortran order. 8639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah trans = transpose(flattened, shape) 8649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected = ndarray(trans, shape=shape, format=ff, 8659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 8669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: # 'C', 'A' 8679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_contiguous(result, 'A') or \ 8689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah is_contiguous(result, 'F') and order == 'C': 8699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # The flattened list is already in C-order. 8709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah expected = ndarray(flattened, shape=shape, format=ff) 8717d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah contig = get_contiguous(result, PyBUF_READ, order) 8739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(contig.tobytes(), b) 8749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(cmp_contig(contig, expected)) 8759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 8767d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if ndim == 0: 8777d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 8787d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8797d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nmemb = len(flattened) 8807d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ro = 0 if readonly else ND_WRITABLE 8817d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8827d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### See comment in test_py_buffer_to_contiguous for an 8837d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### explanation why these tests are valid. 8847d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8857d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # To 'C' 8867d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah contig = py_buffer_to_contiguous(result, 'C', PyBUF_FULL_RO) 8877d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(len(contig), nmemb * itemsize) 88806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [struct.unpack_from(fmt, contig, n*itemsize) 8897d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for n in range(nmemb)] 89006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if len(initlst[0]) == 1: 89106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [v[0] for v in initlst] 8927d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8937d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray(initlst, shape=shape, flags=ro, format=fmt) 8947d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(result)) 8957d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 8967d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # To 'F' 8977d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah contig = py_buffer_to_contiguous(result, 'F', PyBUF_FULL_RO) 8987d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(len(contig), nmemb * itemsize) 89906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [struct.unpack_from(fmt, contig, n*itemsize) 9007d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for n in range(nmemb)] 90106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if len(initlst[0]) == 1: 90206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [v[0] for v in initlst] 9037d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 9047d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray(initlst, shape=shape, flags=ro|ND_FORTRAN, 9057d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah format=fmt) 9067d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(result)) 9077d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 9087d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # To 'A' 9097d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah contig = py_buffer_to_contiguous(result, 'A', PyBUF_FULL_RO) 9107d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(len(contig), nmemb * itemsize) 91106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [struct.unpack_from(fmt, contig, n*itemsize) 9127d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for n in range(nmemb)] 91306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if len(initlst[0]) == 1: 91406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan initlst = [v[0] for v in initlst] 9157d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 9167d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah f = ND_FORTRAN if is_contiguous(result, 'F') else 0 9177d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray(initlst, shape=shape, flags=f|ro, format=fmt) 9187d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(result)) 9197d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 9209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 9219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 9229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(result) 9239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except BufferError: # re-exporter does not provide full information 9249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 9259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = result.obj if isinstance(result, memoryview) else result 9269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(m.obj, ex) 9279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.nbytes, expected_len) 9289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.itemsize, itemsize) 9299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.format, fmt) 9309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.readonly, readonly) 9319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.ndim, ndim) 9329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.shape, tuple(shape)) 9339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not (sliced and suboffsets): 9349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.strides, tuple(strides)) 9359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.suboffsets, tuple(suboffsets)) 9369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = 1 if ndim == 0 else len(lst) 9389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(len(m), n) 9399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rep = result.tolist() if fmt else result.tobytes() 9419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(rep, lst) 9429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, result) 9439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def verify_getbuf(self, orig_ex, ex, req, sliced=False): 9459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def simple_fmt(ex): 9469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ex.format == '' or ex.format == 'B' 9479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def match(req, flag): 9489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return ((req&flag) == flag) 9499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if (# writable request to read-only exporter 9519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (ex.readonly and match(req, PyBUF_WRITABLE)) or 9529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cannot match explicit contiguity request 9539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (match(req, PyBUF_C_CONTIGUOUS) and not ex.c_contiguous) or 9549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (match(req, PyBUF_F_CONTIGUOUS) and not ex.f_contiguous) or 9559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (match(req, PyBUF_ANY_CONTIGUOUS) and not ex.contiguous) or 9569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # buffer needs suboffsets 9579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (not match(req, PyBUF_INDIRECT) and ex.suboffsets) or 9589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # buffer without strides must be C-contiguous 9599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (not match(req, PyBUF_STRIDES) and not ex.c_contiguous) or 9609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyBUF_SIMPLE|PyBUF_FORMAT and PyBUF_WRITABLE|PyBUF_FORMAT 9619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (not match(req, PyBUF_ND) and match(req, PyBUF_FORMAT))): 9629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=req) 9649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return 9659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if isinstance(ex, ndarray) or is_memoryview_format(ex.format): 9679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = ex.tolist() 9689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 9699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_FULL_RO) 9709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = nd.tolist() 9719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # The consumer may have requested default values or a NULL format. 9739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ro = 0 if match(req, PyBUF_WRITABLE) else ex.readonly 9749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt = ex.format 9759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = ex.itemsize 9769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = ex.ndim 9779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not match(req, PyBUF_FORMAT): 9789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # itemsize refers to the original itemsize before the cast. 9799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # The equality product(shape) * itemsize = len still holds. 9809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # The equality calcsize(format) = itemsize does _not_ hold. 9819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt = '' 9829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = orig_ex.tobytes() # Issue 12834 9839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not match(req, PyBUF_ND): 9849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = 1 9859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = orig_ex.shape if match(req, PyBUF_ND) else () 9869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = orig_ex.strides if match(req, PyBUF_STRIDES) else () 9879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=req) 9899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=ex, 9909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=ro, 9919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 9929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, sliced=sliced) 9939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 9949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_getbuf(self): 9959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah requests = ( 9969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # distinct flags 9979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_INDIRECT, PyBUF_STRIDES, PyBUF_ND, PyBUF_SIMPLE, 9989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_C_CONTIGUOUS, PyBUF_F_CONTIGUOUS, PyBUF_ANY_CONTIGUOUS, 9999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # compound requests 10009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_FULL, PyBUF_FULL_RO, 10019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_RECORDS, PyBUF_RECORDS_RO, 10029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_STRIDED, PyBUF_STRIDED_RO, 10039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_CONTIG, PyBUF_CONTIG_RO, 10049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 10059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # items and format 10069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items_fmt = ( 10079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([True if x % 2 else False for x in range(12)], '?'), 10089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([1,2,3,4,5,6,7,8,9,10,11,12], 'b'), 10099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([1,2,3,4,5,6,7,8,9,10,11,12], 'B'), 10109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([(2**31-x) if x % 2 else (-2**31+x) for x in range(12)], 'l') 10119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 10129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # shape, strides, offset 10139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah structure = ( 10149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([], [], 0), 1015363af44a4abff02ece61e456d55824f298448992Stefan Krah ([1,3,1], [], 0), 10169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([12], [], 0), 10179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([12], [-1], 11), 10189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([6], [2], 0), 10199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([6], [-2], 11), 10209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([3, 4], [], 0), 10219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([3, 4], [-4, -1], 11), 10229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([2, 2], [4, 1], 4), 10239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ([2, 2], [-4, -1], 8) 10249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 10259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndarray creation flags 10269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndflags = ( 10279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 0, ND_WRITABLE, ND_FORTRAN, ND_FORTRAN|ND_WRITABLE, 10289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ND_PIL, ND_PIL|ND_WRITABLE 10299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 10309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flags that can actually be used as flags 10319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah real_flags = (0, PyBUF_WRITABLE, PyBUF_FORMAT, 10329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah PyBUF_WRITABLE|PyBUF_FORMAT) 10339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for items, fmt in items_fmt: 10359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 10369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape, strides, offset in structure: 10379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = [v * itemsize for v in strides] 10389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset *= itemsize 10399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in ndflags: 10409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if strides and (flags&ND_FORTRAN): 10429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 10439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not shape and (flags&ND_PIL): 10449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 10459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah _items = items if shape else items[0] 10479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(_items, format=fmt, flags=flags, 10489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape=shape, strides=strides, offset=offset) 10499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ex1[::-2] if shape else None 10509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(ex1) 10529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ex2: 10539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(ex2) 10549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ex1.ndim == 0 or (ex1.ndim == 1 and shape and strides): 10559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, ex1) 10569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ex2 and ex2.ndim == 1 and shape and strides: 10579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m2, ex2) 10589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for req in requests: 10609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for bits in real_flags: 10619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify_getbuf(ex1, ex1, req|bits) 10629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify_getbuf(ex1, m1, req|bits) 10639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ex2: 10649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify_getbuf(ex2, ex2, req|bits, 10659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sliced=True) 10669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify_getbuf(ex2, m2, req|bits, 10679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sliced=True) 10689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10,11,12] 10709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_GETBUF_FAIL 10729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[12], flags=ND_GETBUF_FAIL) 10739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex) 10749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 10759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Request complex structure from a simple exporter. In this 10769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # particular case the test object is not PEP-3118 compliant. 10779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah base = ndarray([9], [1]) 10789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(base, getbuf=PyBUF_SIMPLE) 10799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_WRITABLE) 10809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_ND) 10819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_STRIDES) 10829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_C_CONTIGUOUS) 10839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_F_CONTIGUOUS) 10849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, ex, getbuf=PyBUF_ANY_CONTIGUOUS) 10859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 10869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 1087363af44a4abff02ece61e456d55824f298448992Stefan Krah # Issue #22445: New precise contiguity definition. 1088363af44a4abff02ece61e456d55824f298448992Stefan Krah for shape in [1,12,1], [7,0,7]: 1089363af44a4abff02ece61e456d55824f298448992Stefan Krah for order in 0, ND_FORTRAN: 1090363af44a4abff02ece61e456d55824f298448992Stefan Krah ex = ndarray(items, shape=shape, flags=order|ND_WRITABLE) 1091363af44a4abff02ece61e456d55824f298448992Stefan Krah self.assertTrue(is_contiguous(ex, 'F')) 1092363af44a4abff02ece61e456d55824f298448992Stefan Krah self.assertTrue(is_contiguous(ex, 'C')) 1093363af44a4abff02ece61e456d55824f298448992Stefan Krah 1094363af44a4abff02ece61e456d55824f298448992Stefan Krah for flags in requests: 1095363af44a4abff02ece61e456d55824f298448992Stefan Krah nd = ndarray(ex, getbuf=flags) 1096363af44a4abff02ece61e456d55824f298448992Stefan Krah self.assertTrue(is_contiguous(nd, 'F')) 1097363af44a4abff02ece61e456d55824f298448992Stefan Krah self.assertTrue(is_contiguous(nd, 'C')) 1098363af44a4abff02ece61e456d55824f298448992Stefan Krah 10999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_exceptions(self): 11009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([9], [1]) 11019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndm = ndarray([9], [1], flags=ND_VAREXPORT) 11029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Initialization of a new ndarray or mutation of an existing array. 11049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for c in (ndarray, nd.push, ndm.push): 11059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid types. 11069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, {1,2,3}) 11079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,'3']) 11089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,(3,4)]) 11099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,3], shape={3}) 11109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,3], shape=[3], strides={1}) 11119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1,2,3], shape=[3], offset=[]) 11129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], format={}) 11139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], flags={}) 11149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], getbuf={}) 11159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_FORTRAN flag is only valid without strides. 11179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], strides=[1], 11189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 11199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_PIL flag is only valid with ndim > 0. 11219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[], flags=ND_PIL) 11229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid items. 11249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [], shape=[1]) 11259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, ['XXX'], shape=[1], format="L") 11269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid combination of items and format. 11279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(struct.error, c, [1000], shape=[1], format="B") 11289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,(2,3)], shape=[2], format="B") 11299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[3], format="QL") 11309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid ndim. 11329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = ND_MAX_NDIM+1 11339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1]*n, shape=[1]*n) 11349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid shape. 11369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1], shape=[-1]) 11379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=['3']) 11389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, c, [1], shape=[2**128]) 11399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # prod(shape) * itemsize != len(items) 11409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3,4,5], shape=[2,2], offset=3) 11419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid strides. 11439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[3], strides=['1']) 11449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, c, [1], shape=[1], 11459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides=[2**128]) 11469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid combination of strides and shape. 11489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2], shape=[2,1], strides=[1]) 11499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid combination of strides and format. 11509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3,4], shape=[2], strides=[3], 11519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format="L") 11529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid offset. 11549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[3], offset=4) 11559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[1], offset=3, 11569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format="L") 11579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid format. 11599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, [1,2,3], shape=[3], format="") 11609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(struct.error, c, [(1,2,3)], shape=[1], 11619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format="@#$") 11629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Striding out of the memory bounds. 11649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10] 11659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, c, items, shape=[2,3], 11669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides=[-3, -2], offset=5) 11679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Constructing consumer: format argument invalid. 11699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, bytearray(), format="Q") 11709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Constructing original base object: getbuf argument invalid. 11729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1], shape=[1], getbuf=PyBUF_FULL) 11739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Shape argument is mandatory for original base objects. 11759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, c, [1]) 11769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyBUF_WRITABLE request to read-only provider. 11799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, ndarray, b'123', getbuf=PyBUF_WRITABLE) 11809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_VAREXPORT can only be specified during construction. 11829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([9], [1], flags=ND_VAREXPORT) 11839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.push, [1], [1], flags=ND_VAREXPORT) 11849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid operation for consumers: push/pop 11869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(b'123') 11879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.push, [1], [1]) 11889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.pop) 11899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND_VAREXPORT not set: push/pop fail with exported buffers 11919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([9], [1]) 11929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.push([1], [1]) 11939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 11949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.push, [1], [1]) 11959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.pop) 11969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m.release() 11979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.pop() 11989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 11999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Single remaining buffer: pop fails 12009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.pop) 12019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 12029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # get_pointer() 12049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_pointer, {}, [1,2,3]) 12059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_pointer, b'123', {}) 12069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(100)), shape=[1]*100) 12089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_pointer, nd, [5]) 12099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3,4]) 12119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_pointer, nd, [2,3,4]) 12129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_pointer, nd, [3,3]) 12139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_pointer, nd, [-3,3]) 12149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, get_pointer, nd, [1<<64,3]) 12159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # tolist() needs format 12179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([1,2,3], shape=[3], format='L') 12189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 12199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.tolist) 12209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview_from_buffer() 12229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray([1,2,3], shape=[3], format='L') 12239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ndarray(ex1) 12249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex2) 12259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.memoryview_from_buffer) 12269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([(1,)*200], shape=[1], format='L'*200) 12289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.memoryview_from_buffer) 12299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = ND_MAX_NDIM 12319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(n)), shape=[1]*n) 12329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.memoryview_from_buffer) 12339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # get_contiguous() 12359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1]) 12369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_contiguous, 1, 2, 3, 4, 5) 12379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_contiguous, nd, "xyz", 'C') 12389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, get_contiguous, nd, 2**64, 'C') 12399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_contiguous, nd, PyBUF_READ, 961) 12409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(UnicodeEncodeError, get_contiguous, nd, PyBUF_READ, 12419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah '\u2007') 124266e63170d9aa8cf41a772b0d22b20c47636d24f5Stefan Krah self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'Z') 124366e63170d9aa8cf41a772b0d22b20c47636d24f5Stefan Krah self.assertRaises(ValueError, get_contiguous, nd, 255, 'A') 12449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cmp_contig() 12469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1]) 12479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, cmp_contig, 1, 2, 3, 4, 5) 12489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, cmp_contig, {}, nd) 12499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, cmp_contig, nd, {}) 12509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # is_contiguous() 12529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1]) 12539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, is_contiguous, 1, 2, 3, 4, 5) 12549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, is_contiguous, {}, 'A') 12559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, is_contiguous, nd, 201) 12569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_linked_list(self): 12589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for perm in permutations(range(5)): 12599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = [0]*5 12609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[3], flags=ND_VAREXPORT) 12619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[0] = memoryview(nd) 12629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(1, 5): 12649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.push([1,2,3], shape=[3]) 12659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[i] = memoryview(nd) 12669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(5): 12689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[perm[i]].release() 12699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.pop) 12719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 12729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_format_scalar(self): 12749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 0: scalar 12759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, scalar, _ in iter_format(0): 12769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 12779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(scalar, shape=(), format=fmt) 12789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 12799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 12809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=0, shape=(), strides=(), 12819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=scalar) 12829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_format_shape(self): 12849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 1, shape = [n] 12859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = randrange(1, 10) 12869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(nitems): 12879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 12889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 12899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[nitems], format=fmt, flags=flags) 12909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 12919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 12929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=(nitems,), strides=(itemsize,), 12939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=items) 12949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 12959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_format_strides(self): 12969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 1, strides 12979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = randrange(1, 30) 12989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(nitems): 12999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 13009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for step in range(-5, 5): 13019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if step == 0: 13029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 13039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = [len(items[::step])] 13059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = [step*itemsize] 13069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah offset = itemsize*(nitems-1) if step < 0 else 0 13079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 13099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, strides=strides, 13109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah format=fmt, offset=offset, flags=flags) 13119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 13129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 13139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=shape, strides=strides, 13149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=items[::step]) 13159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_fortran(self): 13179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10,11,12] 13189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=(3, 4), strides=(1, 3)) 13199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_F_CONTIGUOUS|PyBUF_FORMAT) 13209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), farray(items, (3, 4))) 13219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_multidim(self): 13239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for ndim in range(5): 13249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = [randrange(2, 10) for _ in range(ndim)] 13259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 13269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 13279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 13299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 13309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 13329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if ndim == 0 and flags == ND_PIL: 13339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 13349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C array 13369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, flags=flags) 13379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = strides_from_shape(ndim, shape, itemsize, 'C') 13399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 13409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 13419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 13429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 13439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 13449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 13469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview: reconstruct strides 13479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, format=fmt) 13489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO|PyBUF_FORMAT) 13499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(nd.strides == ()) 13509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = nd.memoryview_from_buffer() 13519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(mv, obj=None, 13529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 13539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 13549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 13559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran array 13579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, 13589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=flags|ND_FORTRAN) 13599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = strides_from_shape(ndim, shape, itemsize, 'F') 13619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = farray(items, shape) 13629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(nd, obj=None, 13639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=itemsize, fmt=fmt, readonly=1, 13649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 13659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 13669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_invalid(self): 13689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # not writable 13699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1]) 13709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__setitem__, 1, 8) 13719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 13729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 13739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__setitem__, 1, 8) 13749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cannot be deleted 13769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1], flags=ND_WRITABLE) 13779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__delitem__, 1) 13789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 13799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 13809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__delitem__, 1) 13819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # overflow 13839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1], flags=ND_WRITABLE) 13849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, nd.__getitem__, 1<<64) 13859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, nd.__setitem__, 1<<64, 8) 13869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 13879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 13889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__getitem__, 1<<64) 13899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__setitem__, 1<<64, 8) 13909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 13919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # format 13929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8] 13939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[len(items)], format="B", flags=ND_WRITABLE) 13949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(struct.error, nd.__setitem__, 2, 300) 13959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__setitem__, 1, (100, 200)) 13969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 13979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 13989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, mv.__setitem__, 2, 300) 13999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__setitem__, 1, (100, 200)) 14009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [(1,2), (3,4), (5,6)] 14029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[len(items)], format="LQ", flags=ND_WRITABLE) 14039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__setitem__, 2, 300) 14049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(struct.error, nd.__setitem__, 1, (b'\x001', 200)) 14059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_scalar(self): 14079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # scalar 14089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(1, shape=(), flags=ND_WRITABLE) 14099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 14109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 14119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd[()]; self.assertEqual(x, 1) 14139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd[...]; self.assertEqual(x.tolist(), nd.tolist()) 14149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = mv[()]; self.assertEqual(x, 1) 14169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = mv[...]; self.assertEqual(x.tolist(), nd.tolist()) 14179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__getitem__, 0) 14199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__getitem__, 0) 14209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__setitem__, 0, 8) 14219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__setitem__, 0, 8) 14229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), 1) 14249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), 1) 14259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[()] = 9; self.assertEqual(nd.tolist(), 9) 14279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[()] = 9; self.assertEqual(mv.tolist(), 9) 14289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[...] = 5; self.assertEqual(nd.tolist(), 5) 14309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[...] = 5; self.assertEqual(mv.tolist(), 5) 14319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_null_strides(self): 14339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(2*4)), shape=[2, 4], flags=ND_WRITABLE) 14349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG) 14359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Sub-views are only possible for full exporters. 14379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.__getitem__, 1) 14389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Same for slices. 14399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, nd.__getitem__, slice(3,5,1)) 14409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_getitem_single(self): 14429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getitem 14439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(5): 14449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt) 14459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], items[i]) 14479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, nd.__getitem__, -6) 14499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, nd.__getitem__, 5) 14509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 14529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 14539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 14549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv[i], items[i]) 14569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__getitem__, -6) 14589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__getitem__, 5) 14599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getitem with null strides 14619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(5): 14629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[5], flags=ND_WRITABLE, format=fmt) 14639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG|PyBUF_FORMAT) 14649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], items[i]) 14679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 14699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = nd.memoryview_from_buffer() 14709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(mv.__eq__(nd), NotImplemented) 14719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv[i], items[i]) 14739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getitem with null format 14759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5] 14769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[5]) 14779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO) 14789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], items[i]) 14809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getitem with null shape/strides/format 14829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5] 14839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[5]) 14849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 14859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 5): 14879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], items[i]) 14889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_setitem_single(self): 14909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # assign single value 14919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, single_item in iter_format(5): 14929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE) 14939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(5): 14949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items[i] = single_item 14959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[i] = single_item 14969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), items) 14979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 14989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, nd.__setitem__, -6, single_item) 14999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, nd.__setitem__, 5, single_item) 15009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_memoryview_format(fmt): 15029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 15039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE) 15059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 15079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(5): 15089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items[i] = single_item 15099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[i] = single_item 15109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), items) 15119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__setitem__, -6, single_item) 15139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, mv.__setitem__, 5, single_item) 15149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # assign single value: lobject = robject 15179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, single_item in iter_format(5): 15189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE) 15199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 4): 15209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items[i] = items[i+1] 15219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[i] = nd[i+1] 15229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), items) 15239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_memoryview_format(fmt): 15259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 15269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=ND_WRITABLE) 15289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 15309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-5, 4): 15319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items[i] = items[i+1] 15329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[i] = mv[i+1] 15339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), items) 15349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_index_getitem_multidim(self): 15369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = (2, 3, 5) 15379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 15389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 15399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 15419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 15439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C array 15449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, flags=flags) 15459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 15469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-shape[0], shape[0]): 15489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i], nd[i].tolist()) 15499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for j in range(-shape[1], shape[1]): 15509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i][j], nd[i][j].tolist()) 15519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for k in range(-shape[2], shape[2]): 15529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i][j][k], nd[i][j][k]) 15539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran array 15559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, 15569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=flags|ND_FORTRAN) 15579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = farray(items, shape) 15589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(-shape[0], shape[0]): 15609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i], nd[i].tolist()) 15619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for j in range(-shape[1], shape[1]): 15629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i][j], nd[i][j].tolist()) 15639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for k in range(shape[2], shape[2]): 15649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(lst[i][j][k], nd[i][j][k]) 15659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_sequence(self): 15679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(1, shape=()) 15689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, eval, "1 in nd", locals()) 15699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 15719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, eval, "1 in mv", locals()) 15729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(5): 15749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt) 15759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i, v in enumerate(nd): 15769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, items[i]) 15779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(v in nd) 15789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 15809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 15819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i, v in enumerate(mv): 15829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, items[i]) 15839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(v in mv) 15849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_invalid(self): 15869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8] 15879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # rvalue is not an exporter 15899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], flags=ND_WRITABLE) 15909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 15919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, xl.__setitem__, slice(0,8,1), items) 15929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, ml.__setitem__, slice(0,8,1), items) 15939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 15949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # rvalue is not a full exporter 15959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], flags=ND_WRITABLE) 15969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[8], flags=ND_WRITABLE) 15979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray(ex, getbuf=PyBUF_ND) 15989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, xl.__setitem__, slice(0,8,1), xr) 15999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zero step 16019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[8], format="L", flags=ND_WRITABLE) 16029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 16039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__getitem__, slice(0,1,0)) 16049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, mv.__getitem__, slice(0,1,0)) 16059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[2,4], format="L", flags=ND_WRITABLE) 16079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 16089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__getitem__, 16109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,1,1), slice(0,1,0))) 16119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.__getitem__, 16129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,1,0), slice(0,1,1))) 16139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__getitem__, "@%$") 16149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__getitem__, ("@%$", slice(0,1,1))) 16159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, nd.__getitem__, (slice(0,1,1), {})) 16169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview: not implemented 16189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, mv.__getitem__, 16199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,1,1), slice(0,1,0))) 16209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, mv.__getitem__, "@%$") 16219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # differing format 16239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], format="B", flags=ND_WRITABLE) 16249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray(items, shape=[8], format="b") 16259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 16269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 16279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8]) 16289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xl.tolist(), items) 16299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, ml.__setitem__, slice(0,1,1), mr[7:8]) 16309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), items) 16319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # differing itemsize 16339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], format="B", flags=ND_WRITABLE) 16349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yr = ndarray(items, shape=[8], format="L") 16359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 16369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 16379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8]) 16389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xl.tolist(), items) 16399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, ml.__setitem__, slice(0,1,1), mr[7:8]) 16409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), items) 16419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # differing ndim 16439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[2, 4], format="b", flags=ND_WRITABLE) 16449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray(items, shape=[8], format="b") 16459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 16469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 16479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, xl.__setitem__, slice(0,1,1), xr[7:8]) 16489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xl.tolist(), [[1,2,3,4], [5,6,7,8]]) 16499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, ml.__setitem__, slice(0,1,1), 16509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr[7:8]) 16519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # differing shape 16539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray(items, shape=[8], format="b", flags=ND_WRITABLE) 16549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray(items, shape=[8], format="b") 16559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 16569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 16579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, xl.__setitem__, slice(0,2,1), xr[7:8]) 16589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xl.tolist(), items) 16599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, ml.__setitem__, slice(0,2,1), mr[7:8]) 16609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), items) 16619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # _testbuffer.c module functions 16639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, slice_indices, slice(0,1,2), {}) 16649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, slice_indices, "###########", 1) 16659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, slice_indices, slice(0,1,0), 4) 16669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(items, shape=[8], format="b", flags=ND_PIL) 16689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, x.add_suboffsets) 16699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[8], format="B") 16719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(ex, getbuf=PyBUF_SIMPLE) 16729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, x.add_suboffsets) 16739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_zero_shape(self): 16759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10,11,12] 16769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(items, shape=[12], format="L", flags=ND_WRITABLE) 16789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = ndarray(items, shape=[12], format="L") 16799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x[4:4] = y[9:9] 16809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(x.tolist(), items) 16819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(x) 16839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(y) 16849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml, x) 16859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml, y) 16869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml[4:4] = mr[9:9] 16879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), items) 16889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(items, shape=[3, 4], format="L", flags=ND_WRITABLE) 16909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = ndarray(items, shape=[4, 3], format="L") 16919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x[1:2, 2:2] = y[1:2, 3:3] 16929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(x.tolist(), carray(items, [3, 4])) 16939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 16949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_multidim(self): 16959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = (2, 3, 5) 16969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape_t) 16979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 16989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 16999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 17019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 17029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 17049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, flags=flags) 17059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 17069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for slices in rslices_ndim(ndim, shape): 17089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = None 17109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sliced = multislice(lst, slices) 17129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = e.__class__ 17149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = None 17169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndsliced = nd[slices] 17189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 17209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if nderr or listerr: 17229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, listerr) 17239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 17249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndsliced.tolist(), sliced) 17259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_redundant_suboffsets(self): 17279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = (2, 3, 5, 2) 17289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape_t) 17299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 17309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 17319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 17339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 17349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt) 17369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.add_suboffsets() 17379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, format=fmt) 17389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex.add_suboffsets() 17399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(ex) 17409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 17419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for slices in rslices_ndim(ndim, shape): 17439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = None 17459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sliced = multislice(lst, slices) 17479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = e.__class__ 17499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = None 17519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndsliced = nd[slices] 17539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 17559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if nderr or listerr: 17579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, listerr) 17589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 17599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndsliced.tolist(), sliced) 17609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_assign_single(self): 17629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(5): 17639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for lslice in genslices(5): 17649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for rslice in genslices(5): 17659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 17669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah f = flags|ND_WRITABLE 17689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[5], format=fmt, flags=f) 17699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[5], format=fmt, flags=f) 17709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(ex) 17719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lsterr = None 17739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah diff_structure = None 17749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = items[:] 17759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lval = lst[lslice] 17779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rval = lst[rslice] 17789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst[lslice] = lst[rslice] 17799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah diff_structure = len(lval) != len(rval) 17809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lsterr = e.__class__ 17829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = None 17849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 17859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[lslice] = nd[rslice] 17869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 17879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 17889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if diff_structure: # ndarray cannot change shape 17909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, ValueError) 17919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 17929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), lst) 17939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, lsterr) 17949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_memoryview_format(fmt): 17969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 17979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 17989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mverr = None 17999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 18009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv[lslice] = mv[rslice] 18019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 18029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mverr = e.__class__ 18039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if diff_structure: # memoryview cannot change shape 18059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(mverr, ValueError) 18069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 18079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), lst) 18089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 18099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(mverr, lsterr) 18109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(mv, obj=ex, 18119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=nd.itemsize, fmt=fmt, readonly=0, 18129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=nd.ndim, shape=nd.shape, strides=nd.strides, 18139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=nd.tolist()) 18149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_slice_assign_multidim(self): 18169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape_t = (2, 3, 5) 18179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape_t) 18189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nitems = prod(shape_t) 18199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in permutations(shape_t): 18209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, _ = randitems(nitems) 18229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 18249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(ITERATIONS): 18259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lslices, rslices = randslice_from_shape(ndim, shape) 18269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=shape, format=fmt, 18289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=flags|ND_WRITABLE) 18299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 18309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = None 18329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 18339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah result = multislice_assign(lst, lst, lslices, rslices) 18349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 18359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah listerr = e.__class__ 18369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = None 18389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 18399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[lslices] = nd[rslices] 18409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 18419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 18429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if nderr or listerr: 18449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(nderr, listerr) 18459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 18469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), result) 18479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_random(self): 18499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # construction of valid arrays 18509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(ITERATIONS): 18519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 18529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 18539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah t = rand_structure(itemsize, True, maxdim=MAXDIM, 18559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxshape=MAXSHAPE) 18569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(verify_structure(*t)) 18579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = randitems_from_structure(fmt, t) 18589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray_from_structure(items, fmt, t) 18609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xlist = x.tolist() 18619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(x) 18639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 18649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mvlist = mv.tolist() 18659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mvlist, xlist) 18669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if t[2] > 0: 18689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim > 0: test against suboffsets representation. 18699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = ndarray_from_structure(items, fmt, t, flags=ND_PIL) 18709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ylist = y.tolist() 18719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xlist, ylist) 18729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(y) 18749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if is_memoryview_format(fmt): 18759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, y) 18769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mvlist = mv.tolist() 18779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mvlist, ylist) 18789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if numpy_array: 18809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = t[3] 18819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 0 in shape: 18829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue # http://projects.scipy.org/numpy/ticket/1910 18839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah z = numpy_array_from_structure(items, fmt, t) 18849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(x, obj=None, 18859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=z.itemsize, fmt=fmt, readonly=0, 18869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=z.ndim, shape=z.shape, strides=z.strides, 18879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=z.tolist()) 18889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_random_invalid(self): 18909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # exceptions during construction of invalid arrays 18919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(ITERATIONS): 18929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 18939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 18949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 18959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah t = rand_structure(itemsize, False, maxdim=MAXDIM, 18969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah maxshape=MAXSHAPE) 18979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(verify_structure(*t)) 18989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = randitems_from_structure(fmt, t) 18999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = False 19019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 19029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray_from_structure(items, fmt, t) 19039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 19049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nderr = e.__class__ 19059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(nderr) 19069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if numpy_array: 19089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah numpy_err = False 19099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 19109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = numpy_array_from_structure(items, fmt, t) 19119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 19129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah numpy_err = e.__class__ 19139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 0: # http://projects.scipy.org/numpy/ticket/1910 19159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(numpy_err) 19169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_random_slice_assign(self): 19189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # valid slice assignments 19199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _ in range(ITERATIONS): 19209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 19219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 19229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lshape, rshape, lslices, rslices = \ 19249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah rand_aligned_slices(maxdim=MAXDIM, maxshape=MAXSHAPE) 19259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tl = rand_structure(itemsize, True, shape=lshape) 19269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tr = rand_structure(itemsize, True, shape=rshape) 19279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(verify_structure(*tl)) 19289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(verify_structure(*tr)) 19299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah litems = randitems_from_structure(fmt, tl) 19309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ritems = randitems_from_structure(fmt, tr) 19319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl = ndarray_from_structure(litems, fmt, tl) 19339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xr = ndarray_from_structure(ritems, fmt, tr) 19349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xl[lslices] = xr[rslices] 19359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xllist = xl.tolist() 19369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah xrlist = xr.tolist() 19379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(xl) 19399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(xr) 19409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), xllist) 19419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mr.tolist(), xrlist) 19429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if tl[2] > 0 and tr[2] > 0: 19449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim > 0: test against suboffsets representation. 19459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yl = ndarray_from_structure(litems, fmt, tl, flags=ND_PIL) 19469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yr = ndarray_from_structure(ritems, fmt, tr, flags=ND_PIL) 19479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yl[lslices] = yr[rslices] 19489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yllist = yl.tolist() 19499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah yrlist = yr.tolist() 19509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xllist, yllist) 19519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(xrlist, yrlist) 19529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ml = memoryview(yl) 19549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mr = memoryview(yr) 19559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ml.tolist(), yllist) 19569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mr.tolist(), yrlist) 19579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if numpy_array: 19599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 0 in lshape or 0 in rshape: 19609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue # http://projects.scipy.org/numpy/ticket/1910 19619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah zl = numpy_array_from_structure(litems, fmt, tl) 19639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah zr = numpy_array_from_structure(ritems, fmt, tr) 19649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah zl[lslices] = zr[rslices] 19659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_overlapping(tl) and not is_overlapping(tr): 19679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Slice assignment of overlapping structures 19689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # is undefined in NumPy. 19699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(xl, obj=None, 19709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=zl.itemsize, fmt=fmt, readonly=0, 19719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=zl.ndim, shape=zl.shape, 19729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides=zl.strides, lst=zl.tolist()) 19739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(xr, obj=None, 19759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=zr.itemsize, fmt=fmt, readonly=0, 19769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=zr.ndim, shape=zr.shape, 19779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides=zr.strides, lst=zr.tolist()) 19789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_re_export(self): 19809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3,4,5,6,7,8,9,10,11,12] 19819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[3,4], flags=ND_PIL) 19839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(nd) 19849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(ex.flags & ND_PIL) 19869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(ex.obj, nd) 19879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ex.suboffsets, (0, -1)) 19889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(ex.c_contiguous) 19899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(ex.f_contiguous) 19909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(ex.contiguous) 19919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 19929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_zero_shape(self): 19939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zeros in shape 19949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 19959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[0], flags=flags) 19969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 19979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 19989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), []) 19999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), []) 20009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[0,3,3], flags=flags) 20029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), []) 20039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[3,0,3], flags=flags) 20059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), [[], [], []]) 20069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[3,3,0], flags=flags) 20089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), 20099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [[[], [], []], [[], [], []], [[], [], []]]) 20109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_zero_strides(self): 20129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zero strides 20139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 20149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[5], strides=[0], flags=flags) 20159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv = memoryview(nd) 20169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv, nd) 20179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), [1, 1, 1, 1, 1]) 20189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(mv.tolist(), [1, 1, 1, 1, 1]) 20199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_offset(self): 20219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(20)), shape=[3], offset=7) 20229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.offset, 7) 20239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), [7,8,9]) 20249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_memoryview_from_buffer(self): 20269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 20279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(3)), shape=[3], flags=flags) 20289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = nd.memoryview_from_buffer() 20299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 20309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_get_pointer(self): 20329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 20339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(3)), shape=[3], flags=flags) 20349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i in range(3): 20359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[i], get_pointer(nd, [i])) 20369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_tolist_null_strides(self): 20389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(20)), shape=[2,2,5]) 20399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_ND|PyBUF_FORMAT) 20419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.tolist(), ex.tolist()) 20429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 20449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), ex.tolist()) 20459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_cmp_contig(self): 20479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(cmp_contig(b"123", b"456")) 20499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray(list(range(12)), shape=[3,4]) 20519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = ndarray(list(range(12)), shape=[4,3]) 20529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(cmp_contig(x, y)) 20539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray([1], shape=[1], format="B") 20559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(cmp_contig(x, b'\x01')) 20569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(cmp_contig(b'\x01', x)) 20579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_ndarray_hash(self): 20599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('L', [1,2,3]) 20619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(a) 20629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, hash, nd) 20639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # one-dimensional 20659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(list(range(12))) 20669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[12]) 20689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C-contiguous 20719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3,4]) 20729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3,2,2]) 20759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran contiguous 20789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(transpose(list(range(12)), shape=[4,3])) 20799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3,4], flags=ND_FORTRAN) 20809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(transpose(list(range(12)), shape=[2,3,2])) 20839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,3,2], flags=ND_FORTRAN) 20849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # suboffsets 20879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(list(range(12))) 20889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,2,3], flags=ND_PIL) 20899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(b)) 20909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-byte formats 20929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,2,3], format='L') 20939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(nd), hash(nd.tobytes())) 20949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 20957d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah def test_py_buffer_to_contiguous(self): 20967d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 20977d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # The requests are used in _testbuffer.c:py_buffer_to_contiguous 20987d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # to generate buffers without full information for testing. 20997d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah requests = ( 21007d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # distinct flags 21017d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_INDIRECT, PyBUF_STRIDES, PyBUF_ND, PyBUF_SIMPLE, 21027d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # compound requests 21037d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_FULL, PyBUF_FULL_RO, 21047d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_RECORDS, PyBUF_RECORDS_RO, 21057d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_STRIDED, PyBUF_STRIDED_RO, 21067d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_CONTIG, PyBUF_CONTIG_RO, 21077d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ) 21087d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21097d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # no buffer interface 21107d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertRaises(TypeError, py_buffer_to_contiguous, {}, 'F', 21117d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_FULL_RO) 21127d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21137d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # scalar, read-only request 21147d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray(9, shape=(), format="L", flags=ND_WRITABLE) 21157d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21167d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21177d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21187d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, nd.tobytes()) 21197d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21207d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # zeros in shape 21217d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray([1], shape=[0], format="L", flags=ND_WRITABLE) 21227d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21237d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21247d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21257d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, b'') 21267d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21277d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray(list(range(8)), shape=[2, 0, 7], format="L", 21287d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah flags=ND_WRITABLE) 21297d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21307d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21317d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21327d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, b'') 21337d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21347d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### One-dimensional arrays are trivial, since Fortran and C order 21357d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### are the same. 21367d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21377d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # one-dimensional 21387d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for f in [0, ND_FORTRAN]: 21397d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray([1], shape=[1], format="h", flags=f|ND_WRITABLE) 21407d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ndbytes = nd.tobytes() 21417d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21427d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21437d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21447d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, ndbytes) 21457d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21467d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray([1, 2, 3], shape=[3], format="b", flags=f|ND_WRITABLE) 21477d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ndbytes = nd.tobytes() 21487d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21497d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21507d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21517d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, ndbytes) 21527d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21537d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # one-dimensional, non-contiguous input 21547d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray([1, 2, 3], shape=[2], strides=[2], flags=ND_WRITABLE) 21557d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ndbytes = nd.tobytes() 21567d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21577d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in [PyBUF_STRIDES, PyBUF_FULL]: 21587d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21597d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, ndbytes) 21607d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21617d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = nd[::-1] 21627d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ndbytes = nd.tobytes() 21637d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for order in ['C', 'F', 'A']: 21647d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 21657d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah try: 21667d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, order, request) 21677d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah except BufferError: 21687d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 21697d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, ndbytes) 21707d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 21717d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21727d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### Multi-dimensional arrays: 21737d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21747d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### The goal here is to preserve the logical representation of the 21757d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### input array but change the physical representation if necessary. 21767d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21777d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### _testbuffer example: 21787d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### ==================== 21797d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21807d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### C input array: 21817d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### -------------- 21827d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd = ndarray(list(range(12)), shape=[3, 4]) 21837d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd.tolist() 21847d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [[0, 1, 2, 3], 21857d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [4, 5, 6, 7], 21867d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [8, 9, 10, 11]] 21877d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21887d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### Fortran output: 21897d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### --------------- 21907d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> py_buffer_to_contiguous(nd, 'F', PyBUF_FULL_RO) 21917d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> b'\x00\x04\x08\x01\x05\t\x02\x06\n\x03\x07\x0b' 21927d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 21937d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### The return value corresponds to this input list for 21947d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### _testbuffer's ndarray: 21957d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd = ndarray([0,4,8,1,5,9,2,6,10,3,7,11], shape=[3,4], 21967d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### flags=ND_FORTRAN) 21977d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd.tolist() 21987d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [[0, 1, 2, 3], 21997d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [4, 5, 6, 7], 22007d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [8, 9, 10, 11]] 22017d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22027d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### The logical array is the same, but the values in memory are now 22037d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### in Fortran order. 22047d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22057d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### NumPy example: 22067d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### ============== 22077d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### _testbuffer's ndarray takes lists to initialize the memory. 22087d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### Here's the same sequence in NumPy: 22097d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22107d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### C input: 22117d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### -------- 22127d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd = ndarray(buffer=bytearray(list(range(12))), 22137d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### shape=[3, 4], dtype='B') 22147d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd 22157d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### array([[ 0, 1, 2, 3], 22167d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [ 4, 5, 6, 7], 22177d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [ 8, 9, 10, 11]], dtype=uint8) 22187d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22197d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### Fortran output: 22207d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### --------------- 22217d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> fortran_buf = nd.tostring(order='F') 22227d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> fortran_buf 22237d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### b'\x00\x04\x08\x01\x05\t\x02\x06\n\x03\x07\x0b' 22247d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22257d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd = ndarray(buffer=fortran_buf, shape=[3, 4], 22267d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### dtype='B', order='F') 22277d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22287d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### >>> nd 22297d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### array([[ 0, 1, 2, 3], 22307d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [ 4, 5, 6, 7], 22317d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### [ 8, 9, 10, 11]], dtype=uint8) 22327d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah ### 22337d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22347d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # multi-dimensional, contiguous input 22357d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah lst = list(range(12)) 22367d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for f in [0, ND_FORTRAN]: 22377d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray(lst, shape=[3, 4], flags=f|ND_WRITABLE) 22387d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if numpy_array: 22397d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah na = numpy_array(buffer=bytearray(lst), 22407d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah shape=[3, 4], dtype='B', 22417d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah order='C' if f == 0 else 'F') 22427d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22437d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'C' request 22447d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if f == ND_FORTRAN: # 'F' to 'C' 22457d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(transpose(lst, [4, 3]), shape=[3, 4], 22467d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah flags=ND_WRITABLE) 22477d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = x.tobytes() 22487d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah else: 22497d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = nd.tobytes() 22507d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in requests: 22517d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah try: 22527d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'C', request) 22537d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah except BufferError: 22547d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 22557d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22567d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, expected) 22577d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22587d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # Check that output can be used as the basis for constructing 22597d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # a C array that is logically identical to the input array. 22607d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_WRITABLE) 22617d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 22627d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22637d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if numpy_array: 22647d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, na.tostring(order='C')) 22657d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22667d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'F' request 22677d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if f == 0: # 'C' to 'F' 22687d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(transpose(lst, [3, 4]), shape=[4, 3], 22697d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah flags=ND_WRITABLE) 22707d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah else: 22717d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(lst, shape=[3, 4], flags=ND_WRITABLE) 22727d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = x.tobytes() 22737d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in [PyBUF_FULL, PyBUF_FULL_RO, PyBUF_INDIRECT, 22747d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_STRIDES, PyBUF_ND]: 22757d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah try: 22767d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'F', request) 22777d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah except BufferError: 22787d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 22797d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, expected) 22807d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22817d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # Check that output can be used as the basis for constructing 22827d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # a Fortran array that is logically identical to the input array. 22837d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_FORTRAN|ND_WRITABLE) 22847d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 22857d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22867d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if numpy_array: 22877d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, na.tostring(order='F')) 22887d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 22897d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'A' request 22907d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if f == ND_FORTRAN: 22917d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(lst, shape=[3, 4], flags=ND_WRITABLE) 22927d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = x.tobytes() 22937d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah else: 22947d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah expected = nd.tobytes() 22957d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah for request in [PyBUF_FULL, PyBUF_FULL_RO, PyBUF_INDIRECT, 22967d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah PyBUF_STRIDES, PyBUF_ND]: 22977d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah try: 22987d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'A', request) 22997d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah except BufferError: 23007d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah continue 23017d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23027d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, expected) 23037d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23047d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # Check that output can be used as the basis for constructing 23057d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # an array with order=f that is logically identical to the input 23067d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # array. 23077d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=f|ND_WRITABLE) 23087d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 23097d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23107d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah if numpy_array: 23117d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, na.tostring(order='A')) 23127d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23137d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # multi-dimensional, non-contiguous input 23147d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah nd = ndarray(list(range(12)), shape=[3, 4], flags=ND_WRITABLE|ND_PIL) 23157d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23167d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'C' 23177d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'C', PyBUF_FULL_RO) 23187d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, nd.tobytes()) 23197d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_WRITABLE) 23207d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 23217d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23227d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'F' 23237d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'F', PyBUF_FULL_RO) 23247d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah x = ndarray(transpose(lst, [3, 4]), shape=[4, 3], flags=ND_WRITABLE) 23257d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, x.tobytes()) 23267d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_FORTRAN|ND_WRITABLE) 23277d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 23287d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23297d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah # 'A' 23307d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah b = py_buffer_to_contiguous(nd, 'A', PyBUF_FULL_RO) 23317d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(b, nd.tobytes()) 23327d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah y = ndarray([v for v in b], shape=[3, 4], flags=ND_WRITABLE) 23337d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah self.assertEqual(memoryview(y), memoryview(nd)) 23347d12d9df136b45785fb945dcb4812fdb068a2498Stefan Krah 23359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_construction(self): 23369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items_shape = [(9, []), ([1,2,3], [3]), (list(range(2*3*5)), [2,3,5])] 23389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # NumPy style, C-contiguous: 23409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for items, shape in items_shape: 23419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From PEP-3118 compliant exporter: 23439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape) 23449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 23459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.c_contiguous) 23469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.contiguous) 23479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 23499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = strides_from_shape(ndim, shape, 1, 'C') 23509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 23519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=ex, 23539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 23559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From memoryview: 23589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(m) 23599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 23609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 23629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyMemoryView_FromBuffer(): no strides 23659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO|PyBUF_FORMAT) 23669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.strides, ()) 23679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = nd.memoryview_from_buffer() 23689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=None, 23699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 23719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyMemoryView_FromBuffer(): no format, shape, strides 23749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 23759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.format, '') 23769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.shape, ()) 23779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd.strides, ()) 23789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = nd.memoryview_from_buffer() 23799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = [items] if ndim == 0 else items 23819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=None, 23829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 23839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=[ex.nbytes], strides=(1,), 23849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 23859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # NumPy style, Fortran contiguous: 23879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for items, shape in items_shape: 23889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From PEP-3118 compliant exporter: 23909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, flags=ND_FORTRAN) 23919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 23929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.f_contiguous) 23939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.contiguous) 23949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 23969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = strides_from_shape(ndim, shape, 1, 'F') 23979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = farray(items, shape) 23989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 23999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=ex, 24009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 24019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 24029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 24039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From memoryview: 24059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(m) 24069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 24079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 24089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 24099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 24109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PIL style: 24129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for items, shape in items_shape[1:]: 24139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From PEP-3118 compliant exporter: 24159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, flags=ND_PIL) 24169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 24179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 24199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = carray(items, shape) 24209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m, obj=ex, 24229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 24239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=ex.strides, 24249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 24259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # From memoryview: 24279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(m) 24289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 24299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 24309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=ex.strides, 24319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst) 24329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Invalid number of arguments: 24349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, memoryview, b'9', 'x') 24359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Not a buffer provider: 24369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, memoryview, {}) 24379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Non-compliant buffer provider: 24389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([1,2,3], shape=[3]) 24399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_SIMPLE) 24409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, memoryview, nd) 24419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(ex, getbuf=PyBUF_CONTIG_RO|PyBUF_FORMAT) 24429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, memoryview, nd) 24439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim > 64 24459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1]*128, shape=[1]*128, format='L') 24469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, memoryview, nd) 24479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, nd.memoryview_from_buffer) 24489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'C') 24499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_contiguous, nd, PyBUF_READ, 'F') 24509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, get_contiguous, nd[::-1], PyBUF_READ, 'C') 24519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast_zero_shape(self): 245360b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou # Casts are undefined if buffer is multidimensional and shape 245460b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou # contains zeros. These arrays are regarded as C-contiguous by 245560b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou # Numpy and PyBuffer_GetContiguous(), so they are not caught by 245660b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou # the test for C-contiguity in memory_cast(). 24579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah items = [1,2,3] 24589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for shape in ([0,3,3], [3,0,3], [0,3,3]): 24599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape) 24609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(ex.c_contiguous) 24619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 24629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, 'c') 246360b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou # Monodimensional empty view can be cast (issue #19014). 246460b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou for fmt, _, _ in iter_format(1, 'memoryview'): 246560b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou msrc = memoryview(b'') 246660b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou m = msrc.cast(fmt) 246760b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou self.assertEqual(m.tobytes(), b'') 246860b183407cbcd19b211c2dd7ed9a59ff189844a8Antoine Pitrou self.assertEqual(m.tolist(), []) 24699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2470a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou check_sizeof = support.check_sizeof 2471a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou 2472a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou def test_memoryview_sizeof(self): 2473a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou check = self.check_sizeof 2474a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou vsize = support.calcvobjsize 247563afdaa1105de24e87658e82de314a37d341f02bAntoine Pitrou base_struct = 'Pnin 2P2n2i5P P' 2476a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou per_dim = '3n' 2477a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou 2478a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou items = list(range(8)) 2479a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou check(memoryview(b''), vsize(base_struct + 1 * per_dim)) 2480a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou a = ndarray(items, shape=[2, 4], format="b") 2481a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou check(memoryview(a), vsize(base_struct + 2 * per_dim)) 2482a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou a = ndarray(items, shape=[2, 2, 2], format="b") 2483a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou check(memoryview(a), vsize(base_struct + 3 * per_dim)) 2484a654510150cb738b61033c32e30bd4be9f0ed6edAntoine Pitrou 24859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_struct_module(self): 24869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah class INT(object): 24889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def __init__(self, val): 24899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.val = val 24909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def __int__(self): 24919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return self.val 24929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah class IDX(object): 24949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def __init__(self, val): 24959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.val = val 24969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def __index__(self): 24979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah return self.val 24989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 24999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def f(): return 7 25009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah values = [INT(9), IDX(9), 25029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 2.2+3j, Decimal("-21.1"), 12.2, Fraction(5, 2), 25039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [1,2,3], {4,5,6}, {7:8}, (), (9,), 25049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah True, False, None, NotImplemented, 25059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b'a', b'abc', bytearray(b'a'), bytearray(b'abc'), 25069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'a', 'abc', r'a', r'abc', 25079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah f, lambda x: x] 25089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, item in iter_format(10, 'memoryview'): 25109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[10], format=fmt, flags=ND_WRITABLE) 25119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[10], format=fmt, flags=ND_WRITABLE) 25129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 25139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct.pack_into(fmt, nd, 0, item) 25159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[0] = item 25169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[0], nd[0]) 25179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize = struct.calcsize(fmt) 25199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if 'P' in fmt: 25209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 25219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for v in values: 25239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct_err = None 25249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 25259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct.pack_into(fmt, nd, itemsize, v) 25269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except struct.error: 25279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah struct_err = struct.error 25289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv_err = None 25309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 25319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[1] = v 25329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except (TypeError, ValueError) as e: 25339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mv_err = e.__class__ 25349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if struct_err or mv_err: 25369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIsNot(struct_err, None) 25379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIsNot(mv_err, None) 25389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 25399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[1], nd[1]) 25409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast_zero_strides(self): 25429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Casts are undefined if strides contains zeros. These arrays are 25439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # (sometimes!) regarded as C-contiguous by Numpy, but not by 25449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyBuffer_GetContiguous(). 25459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([1,2,3], shape=[3], strides=[0]) 25469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(ex.c_contiguous) 25479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 25489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, 'c') 25499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast_invalid(self): 25519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid format 25529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for sfmt in NON_BYTE_FORMAT: 25539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah sformat = '@' + sfmt if randrange(2) else sfmt 25549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ssize = struct.calcsize(sformat) 25559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for dfmt in NON_BYTE_FORMAT: 25569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dformat = '@' + dfmt if randrange(2) else dfmt 25579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah dsize = struct.calcsize(dformat) 25589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(32)), shape=[32//ssize], format=sformat) 25599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 25609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, dfmt, [32//dsize]) 25619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for sfmt, sitems, _ in iter_format(1): 25639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(sitems, shape=[1], format=sfmt) 25649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 25659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for dfmt, _, _ in iter_format(1): 25660c51595a784787d8e198af910cb6d79172ee52bbStefan Krah if not is_memoryview_format(dfmt): 25679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, msrc.cast, dfmt, 25689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [32//dsize]) 25699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 25709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if not is_byte_format(sfmt) and not is_byte_format(dfmt): 25719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, dfmt, 25729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [32//dsize]) 25739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid shape 25759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size_h = struct.calcsize('h') 25769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size_d = struct.calcsize('d') 25779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(2*2*size_d)), shape=[2,2,size_d], format='h') 25789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah msrc = memoryview(ex) 25799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, msrc.cast, shape=[2,2,size_h], format='d') 25809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(120)), shape=[1,2,3,4,5]) 25829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 25839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect number of args 25859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast) 25869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, 1, 2, 3) 25879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect dest format type 25899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, {}) 25909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect dest format 25929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "X") 25939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "@X") 25949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "@XY") 25959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 25969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # dest format not implemented 25979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "=B") 25989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "!L") 25999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "<P") 26009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, ">l") 26019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "BI") 26029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "xBI") 26039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # src format not implemented 26059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([(1,2), (3,4)], shape=[2], format="II") 26069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__getitem__, 0) 26089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 0, 8) 26099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.tolist) 26109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect shape type 26129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(120)), shape=[1,2,3,4,5]) 26139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "B", shape={}) 26159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # incorrect shape elements 26179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(120)), shape=[2*3*4*5]) 26189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(OverflowError, m.cast, "B", shape=[2**64]) 26209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "B", shape=[-1]) 26219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "B", shape=[2,3,4,5,6,7,-1]) 26229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, "B", shape=[2,3,4,5,6,7,0]) 26239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "B", shape=[2,3,4,5,6,7,'x']) 26249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # N-D -> N-D cast 26269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list([9 for _ in range(3*5*7*11)]), shape=[3,5,7,11]) 26279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "I", shape=[2,3,4,5]) 26299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cast with ndim > 64 26319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(128)), shape=[128], format='I') 26329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 26339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, 'I', [1]*128) 26349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # view->len not a multiple of itemsize 26369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list([9 for _ in range(3*5*7*11)]), shape=[3*5*7*11]) 26379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "I", shape=[2,3,4,5]) 26399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # product(shape) * itemsize != buffer size 26419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list([9 for _ in range(3*5*7*11)]), shape=[3*5*7*11]) 26429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, "B", shape=[2,3,4,5]) 26449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # product(shape) * itemsize overflow 26469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(128)), shape=[128], format='I') 26479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(nd) 26489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(128)), shape=[128], format='B') 26499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(nd) 26509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if sys.maxsize == 2**63-1: 26519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m1.cast, 'B', 26529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [7, 7, 73, 127, 337, 92737, 649657]) 26539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m1.cast, 'B', 26549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [2**20, 2**20, 2**10, 2**10, 2**3]) 26559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.cast, 'I', 26569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [2**20, 2**20, 2**10, 2**10, 2**1]) 26579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 26589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m1.cast, 'B', 26599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [1, 2147483647]) 26609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m1.cast, 'B', 26619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [2**10, 2**10, 2**5, 2**5, 2**1]) 26629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.cast, 'I', 26639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah [2**10, 2**10, 2**5, 2**3, 2**1]) 26649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast(self): 26669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bytespec = ( 26679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ('B', lambda ex: list(ex.tobytes())), 26689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ('b', lambda ex: [x-256 if x > 127 else x for x in list(ex.tobytes())]), 26699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ('c', lambda ex: [bytes(chr(x), 'latin-1') for x in list(ex.tobytes())]), 26709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ) 26719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def iter_roundtrip(ex, m, items, fmt): 26739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah srcsize = struct.calcsize(fmt) 26749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for bytefmt, to_bytelist in bytespec: 26759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m.cast(bytefmt) 26779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = to_bytelist(ex) 26789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 26799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt=bytefmt, readonly=0, 26809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=[31*srcsize], strides=(1,), 26819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 26829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m3 = m2.cast(fmt) 26849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m3, ex) 26859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = ex.tolist() 26869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m3, obj=ex, 26879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=srcsize, fmt=fmt, readonly=0, 26889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=[31], strides=(srcsize,), 26899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 26909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 26919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cast from ndim = 0 to ndim = 1 26929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah srcsize = struct.calcsize('I') 26939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(9, shape=[], format='I') 26949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah destitems, destshape = cast_items(ex, 'B', 1) 26959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 26969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m.cast('B') 26979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 26989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=1, fmt='B', readonly=1, 26999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=1, shape=destshape, strides=(1,), 27009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=destitems, cast=True) 27019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # cast from ndim = 1 to ndim = 0 27039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah destsize = struct.calcsize('I') 27049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([9]*destsize, shape=[destsize], format='B') 27059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah destitems, destshape = cast_items(ex, 'I', destsize, shape=[]) 27069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m.cast('I', shape=[]) 27089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 27099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=destsize, fmt='I', readonly=1, 27109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=0, shape=(), strides=(), 27119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=destitems, cast=True) 27129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # array.array: roundtrip to/from bytes 27149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(31, 'array'): 27159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = array.array(fmt, items) 27169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah iter_roundtrip(ex, m, items, fmt) 27189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndarray: roundtrip to/from bytes 27209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(31, 'memoryview'): 27219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=[31], format=fmt, flags=ND_WRITABLE) 27229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah iter_roundtrip(ex, m, items, fmt) 27249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_cast_1D_ND(self): 27269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Cast between C-contiguous buffers. At least one buffer must 27279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # be 1D, at least one format must be 'c', 'b' or 'B'. 27289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for _tshape in gencastshapes(): 27299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for char in fmtdict['@']: 27309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tfmt = ('', '@')[randrange(2)] + char 27319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tsize = struct.calcsize(tfmt) 27329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = prod(_tshape) * tsize 27339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah obj = 'memoryview' if is_byte_format(tfmt) else 'bytefmt' 27349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, _ in iter_format(n, obj): 27359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size = struct.calcsize(fmt) 27369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah shape = [n] if n > 0 else [] 27379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah tshape = _tshape + [size] 27389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(items, shape=shape, format=fmt) 27409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 27419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah titems, tshape = cast_items(ex, tfmt, tsize, shape=tshape) 27439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if titems is None: 27459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.cast, tfmt, tshape) 27469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 27479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if titems == 'nan': 27489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue # NaNs in lists are a recipe for trouble. 27499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # 1D -> ND 27519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(titems, shape=tshape, format=tfmt) 27529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m.cast(tfmt, shape=tshape) 27549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(tshape) 27559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = nd.strides 27569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = nd.tolist() 27579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m2, obj=ex, 27589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=tsize, fmt=tfmt, readonly=1, 27599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=tshape, strides=strides, 27609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 27619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ND -> 1D 27639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m3 = m2.cast(fmt) 27649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m4 = m2.cast(fmt, shape=shape) 27659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim = len(shape) 27669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah strides = ex.strides 27679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst = ex.tolist() 27689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m3, obj=ex, 27709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=size, fmt=fmt, readonly=1, 27719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 27729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 27739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.verify(m4, obj=ex, 27759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah itemsize=size, fmt=fmt, readonly=1, 27769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ndim=ndim, shape=shape, strides=strides, 27779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst=lst, cast=True) 27789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 27790c51595a784787d8e198af910cb6d79172ee52bbStefan Krah if ctypes: 27800c51595a784787d8e198af910cb6d79172ee52bbStefan Krah # format: "T{>l:x:>d:y:}" 27810c51595a784787d8e198af910cb6d79172ee52bbStefan Krah class BEPoint(ctypes.BigEndianStructure): 27820c51595a784787d8e198af910cb6d79172ee52bbStefan Krah _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_double)] 27830c51595a784787d8e198af910cb6d79172ee52bbStefan Krah point = BEPoint(100, 200.1) 27840c51595a784787d8e198af910cb6d79172ee52bbStefan Krah m1 = memoryview(point) 27850c51595a784787d8e198af910cb6d79172ee52bbStefan Krah m2 = m1.cast('B') 27860c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.obj, point) 27870c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.itemsize, 1) 27880c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.readonly, 0) 27890c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.ndim, 1) 27900c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.shape, (m2.nbytes,)) 27910c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.strides, (1,)) 27920c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.suboffsets, ()) 27930c51595a784787d8e198af910cb6d79172ee52bbStefan Krah 27940c51595a784787d8e198af910cb6d79172ee52bbStefan Krah x = ctypes.c_double(1.2) 27950c51595a784787d8e198af910cb6d79172ee52bbStefan Krah m1 = memoryview(x) 27960c51595a784787d8e198af910cb6d79172ee52bbStefan Krah m2 = m1.cast('c') 27970c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.obj, x) 27980c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.itemsize, 1) 27990c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.readonly, 0) 28000c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.ndim, 1) 28010c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.shape, (m2.nbytes,)) 28020c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.strides, (1,)) 28030c51595a784787d8e198af910cb6d79172ee52bbStefan Krah self.assertEqual(m2.suboffsets, ()) 28040c51595a784787d8e198af910cb6d79172ee52bbStefan Krah 28059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_tolist(self): 28069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Most tolist() tests are in self.verify() etc. 28089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('h', list(range(-6, 6))) 28109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(a) 28119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, a) 28129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), a.tolist()) 28139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = a[2::3] 28159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = m[2::3] 28169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, a) 28179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), a.tolist()) 28189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(2*3*5*7*11)), shape=[11,2,7,3,5], format='L') 28209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), ex.tolist()) 28229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([(2, 5), (7, 11)], shape=[2], format='lh') 28249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.tolist) 28269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([b'12345'], shape=[1], format="s") 28289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.tolist) 28309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([b"a",b"b",b"c",b"d",b"e",b"f"], shape=[2,3], format='s') 28329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.tolist) 28349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_repr(self): 28369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(bytearray(9)) 28379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah r = m.__repr__() 28389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(r.startswith("<memory")) 28399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m.release() 28419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah r = m.__repr__() 28429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(r.startswith("<released")) 28439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_sequence(self): 28459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in ('d', 'f'): 28479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah inf = float(3e400) 28489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = array.array(fmt, [1.0, inf, 3.0]) 28499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIn(1.0, m) 28519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIn(5e700, m) 28529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIn(3.0, m) 28539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(9.0, [], format='f') 28559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, eval, "9.0 in m", locals()) 28579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 285831084ba52856329b972b84299b438bf5b73be292Antoine Pitrou @contextlib.contextmanager 285931084ba52856329b972b84299b438bf5b73be292Antoine Pitrou def assert_out_of_bounds_error(self, dim): 286031084ba52856329b972b84299b438bf5b73be292Antoine Pitrou with self.assertRaises(IndexError) as cm: 286131084ba52856329b972b84299b438bf5b73be292Antoine Pitrou yield 286231084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(str(cm.exception), 286331084ba52856329b972b84299b438bf5b73be292Antoine Pitrou "index out of bounds on dimension %d" % (dim,)) 286431084ba52856329b972b84299b438bf5b73be292Antoine Pitrou 28659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_index(self): 28669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 0 28689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(12.5, shape=[], format='d') 28699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 12.5) 28719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[...], m) 28729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[...], ex) 28739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__getitem__, 0) 28749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray((1,2,3), shape=[], format='iii') 28769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__getitem__, ()) 28789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # range 28809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(7)), shape=[7], flags=ND_WRITABLE) 28819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__getitem__, 2**64) 28849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__getitem__, 2.0) 28859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__getitem__, 0.0) 28869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 28879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # out of bounds 28889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__getitem__, -8) 28899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__getitem__, 8) 28909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 289131084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # multi-dimensional 28929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[3,4], flags=ND_WRITABLE) 28939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 28949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 289531084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(m[0, 0], 0) 289631084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(m[2, 0], 8) 289731084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(m[2, 3], 11) 289831084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(m[-1, -1], 11) 289931084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(m[-3, -4], 0) 290031084ba52856329b972b84299b438bf5b73be292Antoine Pitrou 290131084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # out of bounds 290231084ba52856329b972b84299b438bf5b73be292Antoine Pitrou for index in (3, -4): 290331084ba52856329b972b84299b438bf5b73be292Antoine Pitrou with self.assert_out_of_bounds_error(dim=1): 290431084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[index, 0] 290531084ba52856329b972b84299b438bf5b73be292Antoine Pitrou for index in (4, -5): 290631084ba52856329b972b84299b438bf5b73be292Antoine Pitrou with self.assert_out_of_bounds_error(dim=2): 290731084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[0, index] 290831084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(IndexError, m.__getitem__, (2**64, 0)) 290931084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(IndexError, m.__getitem__, (0, 2**64)) 291031084ba52856329b972b84299b438bf5b73be292Antoine Pitrou 291131084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(TypeError, m.__getitem__, (0, 0, 0)) 291231084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(TypeError, m.__getitem__, (0.0, 0.0)) 291331084ba52856329b972b84299b438bf5b73be292Antoine Pitrou 291431084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # Not implemented: multidimensional sub-views 291531084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(NotImplementedError, m.__getitem__, ()) 29169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__getitem__, 0) 29179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_assign(self): 29199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # ndim = 0 29219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(12.5, shape=[], format='f', flags=ND_WRITABLE) 29229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[()] = 22.5 29249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 22.5) 29259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[...] = 23.5 29269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 23.5) 29279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 0, 24.7) 29289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # read-only 29309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(7)), shape=[7]) 29319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 2, 10) 29339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # range 29359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(7)), shape=[7], flags=ND_WRITABLE) 29369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__setitem__, 2**64, 9) 29399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 2.0, 10) 29409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 0.0, 11) 29419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # out of bounds 29439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__setitem__, -8, 20) 29449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__setitem__, 8, 25) 29459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # pack_single() success: 29479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt in fmtdict['@']: 29489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt == 'c' or fmt == '?': 29499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 29509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([1,2,3], shape=[3], format=fmt, flags=ND_WRITABLE) 29519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah i = randrange(-3, 3) 29539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[i] = 8 29549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[i], 8) 29559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[i], ex[i]) 29569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([b'1', b'2', b'3'], shape=[3], format='c', 29589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE) 29599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[2] = b'9' 29619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[2], b'9') 29629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([True, False, True], shape=[3], format='?', 29649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE) 29659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[1] = True 29679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[1], True) 29689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # pack_single() exceptions: 29709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([b'x'], shape=[1], format='c', flags=ND_WRITABLE) 29719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 29729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 0, 100) 29739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(120)), shape=[1,2,3,4,5], flags=ND_WRITABLE) 29759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(ex) 29769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, _range in fmtdict['@'].items(): 29789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if (fmt == '?'): # PyObject_IsTrue() accepts anything 29799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 29809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt == 'c': # special case tested above 29819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah continue 29829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m1.cast(fmt) 29839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lo, hi = _range 29849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt == 'd' or fmt == 'f': 29859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lo, hi = -2**1024, 2**1024 29869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if fmt != 'P': # PyLong_AsVoidPtr() accepts negative numbers 29879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.__setitem__, 0, lo-1) 29889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m2.__setitem__, 0, "xyz") 29899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.__setitem__, 0, hi) 29909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid item 29929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = m1.cast('c') 29939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m2.__setitem__, 0, b'\xff\xff') 29949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 29959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # format not implemented 29969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(1)), shape=[1], format="xL", flags=ND_WRITABLE) 29979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 29989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 0, 1) 29999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray([b'12345'], shape=[1], format="s", flags=ND_WRITABLE) 30019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 30029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 0, 1) 30039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 300431084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # multi-dimensional 30059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[3,4], flags=ND_WRITABLE) 30069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 300731084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[0,1] = 42 300831084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(ex[0][1], 42) 300931084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[-1,-1] = 43 301031084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertEqual(ex[2][3], 43) 301131084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # errors 301231084ba52856329b972b84299b438bf5b73be292Antoine Pitrou for index in (3, -4): 301331084ba52856329b972b84299b438bf5b73be292Antoine Pitrou with self.assert_out_of_bounds_error(dim=1): 301431084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[index, 0] = 0 301531084ba52856329b972b84299b438bf5b73be292Antoine Pitrou for index in (4, -5): 301631084ba52856329b972b84299b438bf5b73be292Antoine Pitrou with self.assert_out_of_bounds_error(dim=2): 301731084ba52856329b972b84299b438bf5b73be292Antoine Pitrou m[0, index] = 0 301831084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(IndexError, m.__setitem__, (2**64, 0), 0) 301931084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(IndexError, m.__setitem__, (0, 2**64), 0) 302031084ba52856329b972b84299b438bf5b73be292Antoine Pitrou 302131084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(TypeError, m.__setitem__, (0, 0, 0), 0) 302231084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(TypeError, m.__setitem__, (0.0, 0.0), 0) 30239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 302431084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # Not implemented: multidimensional sub-views 30259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 0, [2, 3]) 30269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_slice(self): 30289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE) 30309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 30319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zero step 30339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__getitem__, slice(0,2,0)) 30349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__setitem__, slice(0,2,0), 30359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bytearray([1,2])) 30369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 303731084ba52856329b972b84299b438bf5b73be292Antoine Pitrou # 0-dim slicing (identity function) 303831084ba52856329b972b84299b438bf5b73be292Antoine Pitrou self.assertRaises(NotImplementedError, m.__getitem__, ()) 30399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multidimensional slices 30419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE) 30429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 30439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__getitem__, 30459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,2,1), slice(0,2,1))) 30469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(NotImplementedError, m.__setitem__, 30479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah (slice(0,2,1), slice(0,2,1)), bytearray([1,2])) 30489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # invalid slice tuple 30509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__getitem__, (slice(0,2,1), {})) 30519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, (slice(0,2,1), {}), 30529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah bytearray([1,2])) 30539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # rvalue is not an exporter 30559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, slice(0,1,1), [1]) 30569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-contiguous slice assignment 30589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 30599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(12)), shape=[12], strides=[-1], offset=11, 30609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE|flags) 30619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ndarray(list(range(24)), shape=[12], strides=[2], flags=flags) 30629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(ex1) 30639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(ex2) 30649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1[2:5] = ex1[2:5] 30669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1[2:5] = m2[2:5] 30679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, ex1) 30699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m2, ex2) 30709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1[1:3][::-1] = ex2[0:2][::1] 30729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1[1:3][::-1] = m2[0:2][::1] 30739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, ex1) 30759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m2, ex2) 30769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1[4:1:-2][::-1] = ex1[1:4:2][::1] 30789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1[4:1:-2][::-1] = m1[1:4:2][::1] 30799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, ex1) 30819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m2, ex2) 30829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_array(self): 30849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 30859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def cmptest(testcase, a, b, m, singleitem): 30869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for i, _ in enumerate(a): 30879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ai = a[i] 30889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mi = m[i] 30899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(ai, mi) 30909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a[i] = singleitem 30919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if singleitem != ai: 30929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertNotEqual(a, m) 30939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertNotEqual(a, b) 30949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 30959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(a, m) 30969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(a, b) 30979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[i] = singleitem 30989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(a, m) 30999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah testcase.assertEqual(b, m) 31009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a[i] = ai 31019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[i] = mi 31029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for n in range(1, 5): 31049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for fmt, items, singleitem in iter_format(n, 'array'): 31059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for lslice in genslices(n): 31069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for rslice in genslices(n): 31079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array(fmt, items) 31099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = array.array(fmt, items) 31109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(b) 31119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, a) 31139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), a.tolist()) 31149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), a.tobytes()) 31159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(len(m), len(a)) 31169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah cmptest(self, a, b, m, singleitem) 31189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah array_err = None 31209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah have_resize = None 31219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 31229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah al = a[lslice] 31239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ar = a[rslice] 31249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a[lslice] = a[rslice] 31259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah have_resize = len(al) != len(ar) 31269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 31279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah array_err = e.__class__ 31289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m_err = None 31309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah try: 31319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[lslice] = m[rslice] 31329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah except Exception as e: 31339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m_err = e.__class__ 31349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah if have_resize: # memoryview cannot change shape 31369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(m_err, ValueError) 31379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah elif m_err or array_err: 31389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(m_err, array_err) 31399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah else: 31409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, a) 31419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), a.tolist()) 31429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), a.tobytes()) 31439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah cmptest(self, a, b, m, singleitem) 31449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 314506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_special_cases(self): 31469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('L', [1, 2, 3]) 31489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = array.array('L', [1, 2, 7]) 31499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Ordering comparisons raise: 31519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 31529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(b) 31539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for attr in ('__lt__', '__le__', '__gt__', '__ge__'): 31549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(getattr(v, attr)(w), NotImplemented) 31559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertIs(getattr(a, attr)(v), NotImplemented) 31569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Released views compare equal to themselves: 31589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 31599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v.release() 31609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, v) 31619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, a) 31629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(a, v) 31639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 31659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(a) 31669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w.release() 31679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 31689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, v) 31699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 31709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Operand does not implement the buffer protocol: 31719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 31729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, [1, 2, 3]) 31739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 317406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # NaNs 317506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray([(0, 0)], shape=[1], format='l x d x', flags=ND_WRITABLE) 317606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd[0] = (-1, float('nan')) 317706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(memoryview(nd), nd) 31789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 317906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Depends on issue #15625: the struct module does not understand 'u'. 318006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = array.array('u', 'xyz') 31819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(a) 31829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(a, v) 31839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, a) 31849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 318506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Some ctypes format strings are unknown to the struct module. 318606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if ctypes: 318706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # format: "T{>l:x:>l:y:}" 318806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan class BEPoint(ctypes.BigEndianStructure): 318906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)] 319006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan point = BEPoint(100, 200) 319106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = memoryview(point) 319206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan b = memoryview(point) 319306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, b) 319406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, point) 319506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(point, a) 319606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertRaises(NotImplementedError, a.tolist) 319706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 319806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_ndim_zero(self): 31999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(1729, shape=[], format='@L') 32019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(1729, shape=[], format='L', flags=ND_WRITABLE) 32029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 32039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 32049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 32059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, v) 32069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2) 32079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd2, v) 32089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd1) 32099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd1, w) 32109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(v.__ne__(w)) 32129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(w.__ne__(v)) 32139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w[()] = 1728 32159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 32169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, v) 32179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 32189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(nd2, v) 32199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 32209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(nd1, w) 32219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(v.__eq__(w)) 32239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertFalse(w.__eq__(v)) 32249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE|ND_PIL) 32269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex = ndarray(list(range(12)), shape=[12], flags=ND_WRITABLE|ND_PIL) 32279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(ex) 32289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 32309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[9] = 100 32319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(m, nd) 32329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 323306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # struct module: equal 323406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray((1729, 1.2, b'12345'), shape=[], format='Lf5s') 323506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray((1729, 1.2, b'12345'), shape=[], format='hf5s', 323606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_WRITABLE) 323706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 323806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 323906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 324006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, v) 324106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 324206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(nd2, v) 324306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 324406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(nd1, w) 324506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 324606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # struct module: not equal 324706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray((1729, 1.2, b'12345'), shape=[], format='Lf5s') 324806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray((-1729, 1.2, b'12345'), shape=[], format='hf5s', 324906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_WRITABLE) 325006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 325106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 325206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 325306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, v) 325406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 325506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(nd2, v) 325606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 325706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(nd1, w) 325806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 325906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 326006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 326106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_ndim_one(self): 326206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 326306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # contiguous 32649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='@h') 32659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([-529, 576, -625, 676, 729], shape=[5], format='@h') 32669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 32679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 32689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 32709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 32719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 32729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 32739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 32749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 327506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # contiguous, struct module 327606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='<i') 327706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([-529, 576, -625, 676, 729], shape=[5], format='>h') 327806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 327906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 328006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 328106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 328206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 328306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 328406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 328506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 328606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 328706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # non-contiguous 32889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([-529, -625, -729], shape=[3], format='@h') 32899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='@h') 32909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 32919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 32929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 32939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2[::2]) 32949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w[::2], nd1) 32959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w[::2]) 32969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v[::-1], w[::-2]) 32979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 329806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # non-contiguous, struct module 329906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([-529, -625, -729], shape=[3], format='!h') 330006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='<l') 330106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 330206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 330306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 330406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2[::2]) 330506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w[::2], nd1) 330606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w[::2]) 330706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v[::-1], w[::-2]) 330806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 330906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # non-contiguous, suboffsets 33109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([-529, -625, -729], shape=[3], format='@h') 33119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='@h', 33129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_PIL) 33139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 33149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 33159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 33169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2[::2]) 33179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w[::2], nd1) 33189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w[::2]) 33199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v[::-1], w[::-2]) 33209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 332106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # non-contiguous, suboffsets, struct module 332206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([-529, -625, -729], shape=[3], format='h 0c') 332306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([-529, 576, -625, 676, -729], shape=[5], format='> h', 332406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL) 332506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 332606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 332706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 332806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2[::2]) 332906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w[::2], nd1) 333006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w[::2]) 333106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v[::-1], w[::-2]) 333206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 333306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_zero_shape(self): 333406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 333506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zeros in shape 33369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([900, 961], shape=[0], format='@h') 33379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([-900, -961], shape=[0], format='@h') 33389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 33399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 33409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 33419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 33429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 33439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2) 33449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd1) 33459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 33469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 334706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zeros in shape, struct module 334806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([900, 961], shape=[0], format='= h0c') 334906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([-900, -961], shape=[0], format='@ i') 335006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 335106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 335206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 335306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 335406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 335506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 335606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 335706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 335806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 335906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_zero_strides(self): 336006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 336106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zero strides 33629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([900, 900, 900, 900], shape=[4], format='@L') 33639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([900], shape=[4], strides=[0], format='L') 33649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 33659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 33669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 33679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 33689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 33699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2) 33709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd1) 33719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 33729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 337306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zero strides, struct module 337406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(900, 900)]*4, shape=[4], format='@ Li') 337506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(900, 900)], shape=[4], strides=[0], format='!L h') 337606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 337706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 337806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 337906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 338006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 338106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 338206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 338306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 338406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 338506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_random_formats(self): 338606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 338706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # random single character native formats 33889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah n = 10 33899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for char in fmtdict['@m']: 33909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah fmt, items, singleitem = randitems(n, 'memoryview', '@', char) 33919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for flags in (0, ND_PIL): 33929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(items, shape=[n], format=fmt, flags=flags) 33939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 33949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 33959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 33969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = nd[::-3] 33979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 33989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 33999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 340006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # random formats 340106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan n = 10 340206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan for _ in range(100): 340306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan fmt, items, singleitem = randitems(n) 340406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan for flags in (0, ND_PIL): 340506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray(items, shape=[n], format=fmt, flags=flags) 340606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 340706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 340806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 340906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = nd[::-3] 341006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 341106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 341206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 341306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_c(self): 341406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 341506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different values 34169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(-15, 15)), shape=[3, 2, 5], format='@h') 34179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(0, 30)), shape=[3, 2, 5], format='@h') 34189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 34199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 34209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 34219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 34229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 34239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 34249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 34259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 34269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 342706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different values, struct module 342806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(0, 1, 2)]*30, shape=[3, 2, 5], format='=f q xxL') 342906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(-1.2, 1, 2)]*30, shape=[3, 2, 5], format='< f 2Q') 343006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 343106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 343206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 343306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 343406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 343506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 343606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 343706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 343806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 343906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different shape 34409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(30)), shape=[2, 3, 5], format='L') 34419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='L') 34429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 34439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 34449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 34459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 34469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 34479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 34489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 34499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 34509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 345106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different shape, struct module 345206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(0, 1, 2)]*21, shape=[3, 7], format='! b B xL') 345306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(0, 1, 2)]*21, shape=[7, 3], format='= Qx l xxL') 34549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 34559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 34569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 34579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 34589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 34599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 34609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 34619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 34629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 346306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # C-contiguous, different format, struct module 346406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(list(range(30)), shape=[2, 3, 5], format='L') 346506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(30)), shape=[2, 3, 5], format='l') 346606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 346706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 346806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 346906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 347006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 347106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 347206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 347306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 347406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 347506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_fortran(self): 347606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 347706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different values 34789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(-15, 15)), shape=[5, 2, 3], format='@h', 34799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 34809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(0, 30)), shape=[5, 2, 3], format='@h', 34819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 34829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 34839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 34849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 34859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 34869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 34879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 34889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 34899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 34909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 349106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different values, struct module 349206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(2**64-1, -1)]*6, shape=[2, 3], format='=Qq', 349306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN) 349406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(-1, 2**64-1)]*6, shape=[2, 3], format='=qQ', 349506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN) 349606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 349706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 349806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 349906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 350006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 350106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 350206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 350306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 350406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 350506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different shape 35069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(-15, 15)), shape=[2, 3, 5], format='l', 35079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 35089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(-15, 15)), shape=[3, 2, 5], format='l', 35099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 35109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 35119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 35129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 35139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 35149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 35159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 35169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 35179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 35189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 351906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different shape, struct module 352006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(list(range(-15, 15)), shape=[2, 3, 5], format='0ll', 35219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 352206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(-15, 15)), shape=[3, 2, 5], format='l', 35239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_FORTRAN) 35249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 35259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 35269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 35279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 35289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 35299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 35309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 35319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 35329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 353306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Fortran-contiguous, different format, struct module 353406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(list(range(30)), shape=[5, 2, 3], format='@h', 353506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN) 353606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(30)), shape=[5, 2, 3], format='@b', 353706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN) 353806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 353906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 354006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 354106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 354206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 354306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 354406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 354506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 354606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 354706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_mixed(self): 354806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 354906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # mixed C/Fortran contiguous 35509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst1 = list(range(-15, 15)) 35519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst2 = transpose(lst1, [3, 2, 5]) 35529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(lst1, shape=[3, 2, 5], format='@l') 35539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(lst2, shape=[3, 2, 5], format='l', flags=ND_FORTRAN) 35549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 35559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 35569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 35579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 35589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 35599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 35609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 356106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # mixed C/Fortran contiguous, struct module 356206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst1 = [(-3.3, -22, b'x')]*30 356306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst1[5] = (-2.2, -22, b'x') 356406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst2 = transpose(lst1, [3, 2, 5]) 356506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(lst1, shape=[3, 2, 5], format='d b c') 356606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(lst2, shape=[3, 2, 5], format='d h c', flags=ND_FORTRAN) 356706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 356806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 356906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 357006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 357106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 357206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 357306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 357406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # different values, non-contiguous 35759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(40)), shape=[5, 8], format='@I') 35769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[3:1:-1, ::-2] 35779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ndarray(list(range(40)), shape=[5, 8], format='I') 35789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:1, ::-2] 35799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 35809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 35819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 35829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 35839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 35849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 35859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 35869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 35879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 358806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # same values, non-contiguous, struct module 358906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(2**31-1, -2**31)]*22, shape=[11, 2], format='=ii') 359006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[3:1:-1, ::-2] 359106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray([(2**31-1, -2**31)]*22, shape=[11, 2], format='>ii') 359206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:3:1, ::-2] 359306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 359406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 359506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 359606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 359706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 359806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 359906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 360006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 360106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 36029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # different shape 36039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(30)), shape=[2, 3, 5], format='b') 36049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[1:3:, ::-2] 36059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='b') 36069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:, ::-2] 36079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 36089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 36099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 36109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 36119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 36129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 36139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 36149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 36159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 361606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # different shape, struct module 361706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray(list(range(30)), shape=[2, 3, 5], format='B') 36189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[1:3:, ::-2] 361906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='b') 36209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:, ::-2] 36219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 36229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 36239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 36249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 36259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 36269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 36279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 36289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 36299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 363006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # different format, struct module 363106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(2, b'123')]*30, shape=[5, 3, 2], format='b3s') 363206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[1:3:, ::-2] 363306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(2, b'123')]*30, shape=[5, 3, 2], format='i3s') 363406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:3:, ::-2] 363506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 363606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 363706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 363806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 363906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 364006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 364106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 364206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 364306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 364406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_zero_shape(self): 364506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 364606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zeros in shape 364706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(list(range(30)), shape=[0, 3, 2], format='i') 364806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(list(range(30)), shape=[5, 0, 2], format='@i') 364906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 365006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 365106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 365206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 365306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 365406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 365506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 365606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 365706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 365806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zeros in shape, struct module 36599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(list(range(30)), shape=[0, 3, 2], format='i') 36609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(30)), shape=[5, 0, 2], format='@i') 36619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 36629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 36639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 36649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 36659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 36669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 36679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 36689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 36699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 367006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_zero_strides(self): 367106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 367206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zero strides 36739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray([900]*80, shape=[4, 5, 4], format='@L') 36749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray([900], shape=[4, 5, 4], strides=[0, 0, 0], format='L') 36759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 36769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 36779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 36789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 36799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 36809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd2) 36819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd1) 36829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 36839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v.tolist(), w.tolist()) 36849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 368506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # zero strides, struct module 368606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray([(1, 2)]*10, shape=[2, 5], format='=lQ') 368706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray([(1, 2)], shape=[2, 5], strides=[0, 0], format='<lQ') 368806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 368906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 369006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 369106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 369206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 369306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 369406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 369506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 369606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 369706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_multidim_suboffsets(self): 369806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 369906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets 37009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(40)), shape=[5, 8], format='@I') 37019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[3:1:-1, ::-2] 37029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex2 = ndarray(list(range(40)), shape=[5, 8], format='I', flags=ND_PIL) 37039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:1, ::-2] 37049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 37059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 37069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 37089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 37099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 37109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 37119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 37129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 371306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, struct module 371406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(2**64-1, -1)]*40, shape=[5, 8], format='=Qq', 371506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_WRITABLE) 371606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1[2][7] = (1, -2) 371706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[3:1:-1, ::-2] 371806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 371906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray([(2**64-1, -1)]*40, shape=[5, 8], format='>Qq', 372006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL|ND_WRITABLE) 372106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2[2][7] = (1, -2) 372206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:3:1, ::-2] 372306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 372406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 372506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 372606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 372706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 372806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 372906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 373006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 373106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 373206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 373306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, different shape 373406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray(list(range(30)), shape=[2, 3, 5], format='b', 373506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL) 37369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[1:3:, ::-2] 37379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(list(range(30)), shape=[3, 2, 5], format='b') 37389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:, ::-2] 37399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 37409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 37419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 37439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 37449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 37459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 37469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 37479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 374806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, different shape, struct module 374906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(2**8-1, -1)]*40, shape=[2, 3, 5], format='Bb', 375006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL|ND_WRITABLE) 375106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[1:2:, ::-2] 375206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 375306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray([(2**8-1, -1)]*40, shape=[3, 2, 5], format='Bb') 375406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:2:, ::-2] 375506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 375606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 375706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 375806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 375906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 376006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 376106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, nd2) 376206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(w, nd1) 376306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(v, w) 376406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 376506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, different format 37669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah ex1 = ndarray(list(range(30)), shape=[5, 3, 2], format='i', flags=ND_PIL) 37679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ex1[1:3:, ::-2] 376806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray(list(range(30)), shape=[5, 3, 2], format='@I', flags=ND_PIL) 376906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ex2[1:3:, ::-2] 377006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 377106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 377206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 377306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 377406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 377506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd2) 377606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd1) 377706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 377806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 377906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # suboffsets, different format, struct module 378006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1 = ndarray([(b'hello', b'', 1)]*27, shape=[3, 3, 3], format='5s0sP', 378106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL|ND_WRITABLE) 378206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1[1][2][2] = (b'sushi', b'', 1) 378306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ex1[1:3:, ::-2] 378406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 378506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex2 = ndarray([(b'hello', b'', 1)]*27, shape=[3, 3, 3], format='5s0sP', 378606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_PIL|ND_WRITABLE) 378706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan ex1[1][2][2] = (b'sushi', b'', 1) 37889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ex2[1:3:, ::-2] 378906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 37909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 37919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 37929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 37949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 37959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, nd2) 37969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(w, nd1) 37979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(v, w) 37989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 37999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # initialize mixed C/Fortran + suboffsets 38009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst1 = list(range(-15, 15)) 38019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah lst2 = transpose(lst1, [3, 2, 5]) 38029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd1 = ndarray(lst1, shape=[3, 2, 5], format='@l', flags=ND_PIL) 38039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd2 = ndarray(lst2, shape=[3, 2, 5], format='l', flags=ND_FORTRAN|ND_PIL) 38049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah v = memoryview(nd1) 38059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah w = memoryview(nd2) 38069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, nd1) 38089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(w, nd2) 38099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(v, w) 38109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 381106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # initialize mixed C/Fortran + suboffsets, struct module 381206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst1 = [(b'sashimi', b'sliced', 20.05)]*30 381306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst1[11] = (b'ramen', b'spicy', 9.45) 381406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan lst2 = transpose(lst1, [3, 2, 5]) 381506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 381606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd1 = ndarray(lst1, shape=[3, 2, 5], format='< 10p 9p d', flags=ND_PIL) 381706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd2 = ndarray(lst2, shape=[3, 2, 5], format='> 10p 9p d', 381806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_FORTRAN|ND_PIL) 381906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan v = memoryview(nd1) 382006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan w = memoryview(nd2) 382106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 382206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, nd1) 382306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(w, nd2) 382406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(v, w) 382506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 382606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan def test_memoryview_compare_not_equal(self): 382706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 382806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # items not equal 382906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan for byteorder in ['=', '<', '>', '!']: 383006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan x = ndarray([2**63]*120, shape=[3,5,2,2,2], format=byteorder+'Q') 383106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan y = ndarray([2**63]*120, shape=[3,5,2,2,2], format=byteorder+'Q', 383206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan flags=ND_WRITABLE|ND_FORTRAN) 383306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan y[2][3][1][1][1] = 1 383406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = memoryview(x) 383506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan b = memoryview(y) 383606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(a, x) 383706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(b, y) 383806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, b) 383906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, y) 384006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(b, x) 384106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 384206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan x = ndarray([(2**63, 2**31, 2**15)]*120, shape=[3,5,2,2,2], 384306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan format=byteorder+'QLH') 384406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan y = ndarray([(2**63, 2**31, 2**15)]*120, shape=[3,5,2,2,2], 384506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan format=byteorder+'QLH', flags=ND_WRITABLE|ND_FORTRAN) 384606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan y[2][3][1][1][1] = (1, 1, 1) 384706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = memoryview(x) 384806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan b = memoryview(y) 384906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(a, x) 385006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(b, y) 385106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, b) 385206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(a, y) 385306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertNotEqual(b, x) 385406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 38559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_check_released(self): 38569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('d', [1.1, 2.2, 3.3]) 38589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(a) 38609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m.release() 38619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # PyMemoryView_FromObject() 38639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, memoryview, m) 38649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview.cast() 38659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.cast, 'c') 38669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # getbuffer() 38679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, ndarray, m) 38689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview.tolist() 38699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.tolist) 38709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # memoryview.tobytes() 38719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.tobytes) 38729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # sequence 38739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, eval, "1.0 in m", locals()) 38749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # subscript 38759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__getitem__, 0) 38769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # assignment 38779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__setitem__, 0, 1) 38789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for attr in ('obj', 'nbytes', 'readonly', 'itemsize', 'format', 'ndim', 38809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'shape', 'strides', 'suboffsets', 'c_contiguous', 38819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 'f_contiguous', 'contiguous'): 38829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(ValueError, m.__getattribute__, attr) 38839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # richcompare 38859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = array.array('d', [1.1, 2.2, 3.3]) 38869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(a) 38879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(b) 38889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, m2) 38909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1.release() 38919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(m1, m2) 38929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertNotEqual(m1, a) 38939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1, m1) 38949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 38959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_tobytes(self): 38969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Many implicit tests are already in self.verify(). 38979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 389806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan t = (-529, 576, -625, 676, -729) 38999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 390006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray(t, shape=[5], format='@h') 39019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 390206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 39039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), nd.tobytes()) 39049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 390506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray([t], shape=[1], format='>hQiLl') 390606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 390706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 390806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m.tobytes(), nd.tobytes()) 390906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 391006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray([t for _ in range(12)], shape=[2,2,3], format='=hQiLl') 391106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 391206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 391306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m.tobytes(), nd.tobytes()) 391406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 391506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan nd = ndarray([t for _ in range(120)], shape=[5,2,2,3,2], 391606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan format='<hQiLl') 391706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan m = memoryview(nd) 391806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m, nd) 391906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(m.tobytes(), nd.tobytes()) 392006e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 392106e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # Unknown formats are handled: tobytes() purely depends on itemsize. 392206e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan if ctypes: 392306e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan # format: "T{>l:x:>l:y:}" 392406e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan class BEPoint(ctypes.BigEndianStructure): 392506e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan _fields_ = [("x", ctypes.c_long), ("y", ctypes.c_long)] 392606e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan point = BEPoint(100, 200) 392706e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan a = memoryview(point) 392806e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan self.assertEqual(a.tobytes(), bytes(point)) 392906e1ab0a6b51c35e4637bb82c3aa18548b6412b0Nick Coghlan 39309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_get_contiguous(self): 39319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Many implicit tests are already in self.verify(). 39329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # no buffer interface 39349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, get_contiguous, {}, PyBUF_READ, 'F') 39359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # writable request to read-only object 39379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, b'x', PyBUF_WRITE, 'C') 39389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # writable request to non-contiguous object 39409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1, 2, 3], shape=[2], strides=[2]) 39419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'A') 39429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # scalar, read-only request from read-only exporter 39449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(9, shape=(), format="L") 39459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 9) 39499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # scalar, read-only request from writable exporter 39519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(9, shape=(), format="L", flags=ND_WRITABLE) 39529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 9) 39569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # scalar, writable request 39589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd[()] = 9 39609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 39619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 9) 39639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m[()] = 10 39659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[()], 10) 39669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[()], 10) 39679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # zeros in shape 39699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[0], format="L", flags=ND_WRITABLE) 39709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(IndexError, m.__getitem__, 0) 39739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), []) 39759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(8)), shape=[2, 0, 7], format="L", 39779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE) 39789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), [[], []]) 39819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # one-dimensional 39839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1], shape=[1], format="h", flags=ND_WRITABLE) 39849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 39869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), nd.tolist()) 39889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1, 2, 3], shape=[3], format="b", flags=ND_WRITABLE) 39909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 39929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 39939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), nd.tolist()) 39949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 39959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # one-dimensional, non-contiguous 39969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1, 2, 3], shape=[2], strides=[2], flags=ND_WRITABLE) 39979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 39989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 39999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 40009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), nd.tolist()) 40019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 1, 20) 40029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[1], 3) 40039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[1], 3) 40049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = nd[::-1] 40069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 40079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 40089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m, nd) 40099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tolist(), nd.tolist()) 40109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(TypeError, m.__setitem__, 1, 20) 40119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m[1], 1) 40129a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(nd[1], 1) 40139a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40149a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multi-dimensional, contiguous input 40159a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3, 4], flags=ND_WRITABLE) 40169a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'A']: 40179a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 40189a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 40199a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'F') 40219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 40229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 40239a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3, 4], 40259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah flags=ND_WRITABLE|ND_FORTRAN) 40269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['F', 'A']: 40279a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_WRITE, order) 40289a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 40299a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40309a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 'C') 40319a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 40329a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 40339a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40349a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multi-dimensional, non-contiguous input 40359a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[3, 4], flags=ND_WRITABLE|ND_PIL) 40369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah for order in ['C', 'F', 'A']: 40379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, get_contiguous, nd, PyBUF_WRITE, 40389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah order) 40399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, order) 40409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(ndarray(m).tolist(), nd.tolist()) 40419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flags 40439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3,4,5], shape=[3], strides=[2]) 40449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = get_contiguous(nd, PyBUF_READ, 'C') 40459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertTrue(m.c_contiguous) 40469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40479a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_serializing(self): 40489a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40499a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C-contiguous 40509a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size = struct.calcsize('i') 40519a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = array.array('i', [1,2,3,4,5]) 40529a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(a) 40539a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf = io.BytesIO(m) 40549a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytearray(5*size) 40559a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf.readinto(b) 40569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), b) 40579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C-contiguous, multi-dimensional 40599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah size = struct.calcsize('L') 40609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,3,2], format="L") 40619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 40629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf = io.BytesIO(m) 40639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytearray(2*3*2*size) 40649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah buf.readinto(b) 40659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m.tobytes(), b) 40669a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40679a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran contiguous, multi-dimensional 40689a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #size = struct.calcsize('L') 40699a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #nd = ndarray(list(range(12)), shape=[2,3,2], format="L", 40709a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # flags=ND_FORTRAN) 40719a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #m = memoryview(nd) 40729a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #buf = io.BytesIO(m) 40739a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #b = bytearray(2*3*2*size) 40749a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #buf.readinto(b) 40759a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah #self.assertEqual(m.tobytes(), b) 40769a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_hash(self): 40789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # bytes exporter 40809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(list(range(12))) 40819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(b) 40829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(b), hash(m)) 40839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # C-contiguous 40859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mc = m.cast('c', shape=[3,4]) 40869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(mc), hash(b)) 40879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-contiguous 40899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah mx = m[::-2] 40909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah b = bytes(list(range(12))[::-2]) 40919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(mx), hash(b)) 40929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Fortran contiguous 40949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(30)), shape=[3,2,5], flags=ND_FORTRAN) 40959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 40969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(m), hash(nd)) 40979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 40989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multi-dimensional slice 40999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(30)), shape=[3,2,5]) 41009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd[::2, ::, ::-1] 41019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(x) 41029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(m), hash(x)) 41039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # multi-dimensional slice with suboffsets 41059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(30)), shape=[2,5,3], flags=ND_PIL) 41069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = nd[::2, ::, ::-1] 41079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(x) 41089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(hash(m), hash(x)) 41099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41104af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah # equality-hash invariant 41114af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah x = ndarray(list(range(12)), shape=[12], format='B') 4112b716f84880fb719be417e9b49f8bb55bfd0106b8Stefan Krah a = memoryview(x) 41134af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 41144af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah y = ndarray(list(range(12)), shape=[12], format='b') 4115b716f84880fb719be417e9b49f8bb55bfd0106b8Stefan Krah b = memoryview(y) 41164af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 4117b716f84880fb719be417e9b49f8bb55bfd0106b8Stefan Krah self.assertEqual(a, b) 4118b716f84880fb719be417e9b49f8bb55bfd0106b8Stefan Krah self.assertEqual(hash(a), hash(b)) 41194af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 41209a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # non-byte formats 41219a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(12)), shape=[2,2,3], format='L') 41229a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 41234af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah self.assertRaises(ValueError, m.__hash__) 41249a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41259a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(list(range(-6, 6)), shape=[2,2,3], format='h') 41269a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(nd) 41274af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah self.assertRaises(ValueError, m.__hash__) 41284af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 41294af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah nd = ndarray(list(range(12)), shape=[2,2,3], format='= L') 41304af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah m = memoryview(nd) 41314af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah self.assertRaises(ValueError, m.__hash__) 41324af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah 41334af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah nd = ndarray(list(range(-6, 6)), shape=[2,2,3], format='< h') 41344af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah m = memoryview(nd) 41354af77a027680f2aa956a4d1c50947d6e2dbd0185Stefan Krah self.assertRaises(ValueError, m.__hash__) 41369a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41379a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_memoryview_release(self): 41389a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41399a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Create re-exporter from getbuffer(memoryview), then release the view. 41409a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = bytearray([1,2,3]) 41419a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m = memoryview(a) 41429a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(m) # re-exporter 41439a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, m.release) 41449a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 41459a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m.release() 41469a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41474e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah a = bytearray([1,2,3]) 41484e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m = memoryview(a) 41494e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd1 = ndarray(m, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 41504e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd2 = ndarray(nd1, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 41514e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(nd2.obj, m) 41524e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertRaises(BufferError, m.release) 41534e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del nd1, nd2 41544e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m.release() 41554e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 41569a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # chained views 41579a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah a = bytearray([1,2,3]) 41589a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(a) 41599a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(m1) 41609a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray(m2) # re-exporter 41619a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1.release() 41629a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, m2.release) 41639a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 41649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2.release() 41659a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41664e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah a = bytearray([1,2,3]) 41674e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m1 = memoryview(a) 41684e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m2 = memoryview(m1) 41694e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd1 = ndarray(m2, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 41704e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd2 = ndarray(nd1, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 41714e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(nd2.obj, m2) 41724e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m1.release() 41734e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertRaises(BufferError, m2.release) 41744e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del nd1, nd2 41754e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m2.release() 41764e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 41779a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # Allow changing layout while buffers are exported. 41789a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd = ndarray([1,2,3], shape=[3], flags=ND_VAREXPORT) 41799a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1 = memoryview(nd) 41809a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41819a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.push([4,5,6,7,8], shape=[5]) # mutate nd 41829a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2 = memoryview(nd) 41839a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41849a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = memoryview(m1) 41859a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(x.tolist(), m1.tolist()) 41869a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41879a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y = memoryview(m2) 41889a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(y.tolist(), m2.tolist()) 41899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(y.tolist(), nd.tolist()) 41909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m2.release() 41919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah y.release() 41929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah nd.pop() # pop the current view 41949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(x.tolist(), nd.tolist()) 41959a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 41969a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah del nd 41979a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah m1.release() 41989a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x.release() 41999a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 42009a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # If multiple memoryviews share the same managed buffer, implicit 42019a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # release() in the context manager's __exit__() method should still 42029a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah # work. 42039a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def catch22(b): 42049a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah with memoryview(b) as m2: 42059a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah pass 42069a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 42079a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = bytearray(b'123') 42089a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah with memoryview(x) as m1: 42099a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah catch22(m1) 42109a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertEqual(m1[0], ord(b'1')) 42119a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 42124e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah x = ndarray(list(range(12)), shape=[2,2,3], format='l') 42134e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 42144e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 42154e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(z.obj, x) 42164e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(z) as m: 42174e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m) 42184e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[0:1].tolist(), [[[0, 1, 2], [3, 4, 5]]]) 42194e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42204e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah # Test garbage collection. 42214e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah for flags in (0, ND_REDIRECT): 42224e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah x = bytearray(b'123') 42234e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(x) as m1: 42244e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del x 42254e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah y = ndarray(m1, getbuf=PyBUF_FULL_RO, flags=flags) 42264e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(y) as m2: 42274e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del y 42284e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah z = ndarray(m2, getbuf=PyBUF_FULL_RO, flags=flags) 42294e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(z) as m3: 42304e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del z 42314e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m3) 42324e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m2) 42334e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m1) 42344e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m1[0], ord(b'1')) 42354e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m2[1], ord(b'2')) 42364e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m3[2], ord(b'3')) 42374e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del m3 42384e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del m2 42394e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del m1 42404e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42414e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah x = bytearray(b'123') 42424e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(x) as m1: 42434e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del x 42444e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah y = ndarray(m1, getbuf=PyBUF_FULL_RO, flags=flags) 42454e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(y) as m2: 42464e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del y 42474e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah z = ndarray(m2, getbuf=PyBUF_FULL_RO, flags=flags) 42484e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah with memoryview(z) as m3: 42494e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del z 42504e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m1) 42514e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m2) 42524e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah catch22(m3) 42534e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m1[0], ord(b'1')) 42544e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m2[1], ord(b'2')) 42554e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m3[2], ord(b'3')) 42564e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del m1, m2, m3 42574e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 4258fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah # memoryview.release() fails if the view has exported buffers. 4259fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah x = bytearray(b'123') 4260fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah with self.assertRaises(BufferError): 4261fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah with memoryview(x) as m: 4262fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah ex = ndarray(m) 4263fcbb4169b982ce06c5701ad18898084dfa569598Stefan Krah m[0] == ord(b'1') 42649a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 42654e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah def test_memoryview_redirect(self): 42664e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42674e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah nd = ndarray([1.0 * x for x in range(12)], shape=[12], format='d') 42684e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah a = array.array('d', [1.0 * x for x in range(12)]) 42694e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42704e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah for x in (nd, a): 42714e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 42724e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 42734e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah m = memoryview(z) 42744e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42754e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(y.obj, x) 42764e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(z.obj, x) 42774e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertIs(m.obj, x) 42784e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42794e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m, x) 42804e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m, y) 42814e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m, z) 42824e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 42834e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[1:3], x[1:3]) 42844e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[1:3], y[1:3]) 42854e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[1:3], z[1:3]) 42864e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah del y, z 42874e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah self.assertEqual(m[1:3], x[1:3]) 42884e99a315b7d10049a16fb1529d2976f13dae5b71Stefan Krah 4289bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah def test_memoryview_from_static_exporter(self): 4290bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4291bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah fmt = 'B' 4292bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst = [0,1,2,3,4,5,6,7,8,9,10,11] 4293bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4294bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # exceptions 4295bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertRaises(TypeError, staticarray, 1, 2, 3) 4296bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4297bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # view.obj==x 4298bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray() 4299bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = memoryview(x) 4300bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(y, obj=x, 4301bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4302bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4303bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4304bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah for i in range(12): 4305bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertEqual(y[i], i) 4306bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x 4307bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del y 4308bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4309bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray() 4310bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = memoryview(x) 4311bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del y 4312bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x 4313bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4314bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray() 4315bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO) 4316bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO) 4317bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah m = memoryview(z) 4318bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(y.obj, x) 4319bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(m.obj, z) 4320bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(m, obj=z, 4321bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4322bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4323bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4324bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x, y, z, m 4325bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4326bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray() 4327bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 4328bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 4329bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah m = memoryview(z) 4330bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(y.obj, x) 4331bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(z.obj, x) 4332bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(m.obj, x) 4333bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(m, obj=x, 4334bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4335bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4336bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4337bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x, y, z, m 4338bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4339bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # view.obj==NULL 4340bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray(legacy_mode=True) 4341bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = memoryview(x) 4342bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(y, obj=None, 4343bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4344bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4345bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4346bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah for i in range(12): 4347bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertEqual(y[i], i) 4348bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x 4349bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del y 4350bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4351bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray(legacy_mode=True) 4352bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = memoryview(x) 4353bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del y 4354bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x 4355bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4356bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray(legacy_mode=True) 4357bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO) 4358bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO) 4359bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah m = memoryview(z) 4360bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(y.obj, None) 4361bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(m.obj, z) 4362bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(m, obj=z, 4363bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4364bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4365bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4366bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x, y, z, m 4367bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 4368bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah x = staticarray(legacy_mode=True) 4369bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah y = ndarray(x, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 4370bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah z = ndarray(y, getbuf=PyBUF_FULL_RO, flags=ND_REDIRECT) 4371bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah m = memoryview(z) 4372bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # Clearly setting view.obj==NULL is inferior, since it 4373bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah # messes up the redirection chain: 4374bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(y.obj, None) 4375bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(z.obj, y) 4376bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.assertIs(m.obj, y) 4377bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah self.verify(m, obj=y, 4378bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah itemsize=1, fmt=fmt, readonly=1, 4379bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah ndim=1, shape=[12], strides=[1], 4380bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah lst=lst) 4381bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah del x, y, z, m 4382bf6c7eca43d7c7d80525c97af08aef52ec81e4a1Stefan Krah 43831649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah def test_memoryview_getbuffer_undefined(self): 43841649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah 43851649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah # getbufferproc does not adhere to the new documentation 43861649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah nd = ndarray([1,2,3], [3], flags=ND_GETBUF_FAIL|ND_GETBUF_UNDEFINED) 43871649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah self.assertRaises(BufferError, memoryview, nd) 43881649c1b33a1d8f46ccf97b8373f62a22bbb3fde6Stefan Krah 43899a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah def test_issue_7385(self): 43909a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah x = ndarray([1,2,3], shape=[3], flags=ND_GETBUF_FAIL) 43919a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah self.assertRaises(BufferError, memoryview, x) 43929a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 43939a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krah 43949a2d99e28a5c2989b2db4023acae4f550885f2efStefan Krahif __name__ == "__main__": 43953e9a9ae09d6fc9169b01cba3efd1ae03ab40b237Brett Cannon unittest.main() 4396