← Back to branch summary

~jtaylor/ubuntu/precise/python-numpy/multiarch-fix-818867

« back to all changes in this revision

Viewing changes to numpy/lib/tests/test_format.py

  • Committer: Bazaar Package Importer
  • Author(s): Ondrej Certik, Riku Voipio, Tiziano Zito, Carlos Galisteo, Ondrej Certik
  • Date: 2008-07-08 15:08:16 UTC
  • mfrom: (0.1.21 intrepid)
  • Revision ID: james.westby@ubuntu.com-20080708150816-ekf992jcp2k1eua3
Tags: 1:1.1.0-3
http://bugs.debian.org/489568
http://bugs.debian.org/489726
[ Riku Voipio ]
* debian/control: atlas is not available on armel, and after a quick look
  neither on alpha. I'd also suggest dropping
  libatlas-sse-dev|libatlas-sse2-dev|libatlas-3dnow-dev alternative combo
  away, these are potentially dangerous on buildd's. Ondrej: dropped.
  (Closes: #489568)

[ Tiziano Zito ]
* patch: build _dotblas.c when ATLAS is not installed, build-conflict with
  atlas, build-depend on blas+lapack only, as it used to be (Closes: #489726)

[ Carlos Galisteo ]
* debian/control
  - Added Homepage field.

[ Ondrej Certik ]
* Checked the package on i386 and amd64, both with and without atlas, all
  tests run and the numpy package is faster if atlas is around. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
numpy/lib/tests/test_format.py
 
1
r''' Test the .npy file format.
 
2
 
 
3
Set up:
 
4
 
 
5
    >>> import numpy as np
 
6
    >>> from cStringIO import StringIO
 
7
    >>> from numpy.lib import format
 
8
    >>>
 
9
    >>> scalars = [
 
10
    ...     np.uint8,
 
11
    ...     np.int8,
 
12
    ...     np.uint16,
 
13
    ...     np.int16,
 
14
    ...     np.uint32,
 
15
    ...     np.int32,
 
16
    ...     np.uint64,
 
17
    ...     np.int64,
 
18
    ...     np.float32,
 
19
    ...     np.float64,
 
20
    ...     np.complex64,
 
21
    ...     np.complex128,
 
22
    ...     object,
 
23
    ... ]
 
24
    >>>
 
25
    >>> basic_arrays = []
 
26
    >>>
 
27
    >>> for scalar in scalars:
 
28
    ...     for endian in '<>':
 
29
    ...         dtype = np.dtype(scalar).newbyteorder(endian)
 
30
    ...         basic = np.arange(15).astype(dtype)
 
31
    ...         basic_arrays.extend([
 
32
    ...             np.array([], dtype=dtype),
 
33
    ...             np.array(10, dtype=dtype),
 
34
    ...             basic,
 
35
    ...             basic.reshape((3,5)),
 
36
    ...             basic.reshape((3,5)).T,
 
37
    ...             basic.reshape((3,5))[::-1,::2],
 
38
    ...         ])
 
39
    ...
 
40
    >>>
 
41
    >>> Pdescr = [
 
42
    ...     ('x', 'i4', (2,)),
 
43
    ...     ('y', 'f8', (2, 2)),
 
44
    ...     ('z', 'u1')]
 
45
    >>>
 
46
    >>>
 
47
    >>> PbufferT = [
 
48
    ...     ([3,2], [[6.,4.],[6.,4.]], 8),
 
49
    ...     ([4,3], [[7.,5.],[7.,5.]], 9),
 
50
    ...     ]
 
51
    >>>
 
52
    >>>
 
53
    >>> Ndescr = [
 
54
    ...     ('x', 'i4', (2,)),
 
55
    ...     ('Info', [
 
56
    ...         ('value', 'c16'),
 
57
    ...         ('y2', 'f8'),
 
58
    ...         ('Info2', [
 
59
    ...             ('name', 'S2'),
 
60
    ...             ('value', 'c16', (2,)),
 
61
    ...             ('y3', 'f8', (2,)),
 
62
    ...             ('z3', 'u4', (2,))]),
 
63
    ...         ('name', 'S2'),
 
64
    ...         ('z2', 'b1')]),
 
65
    ...     ('color', 'S2'),
 
66
    ...     ('info', [
 
67
    ...         ('Name', 'U8'),
 
68
    ...         ('Value', 'c16')]),
 
69
    ...     ('y', 'f8', (2, 2)),
 
70
    ...     ('z', 'u1')]
 
71
    >>>
 
72
    >>>
 
73
    >>> NbufferT = [
 
74
    ...     ([3,2], (6j, 6., ('nn', [6j,4j], [6.,4.], [1,2]), 'NN', True), 'cc', ('NN', 6j), [[6.,4.],[6.,4.]], 8),
 
75
    ...     ([4,3], (7j, 7., ('oo', [7j,5j], [7.,5.], [2,1]), 'OO', False), 'dd', ('OO', 7j), [[7.,5.],[7.,5.]], 9),
 
76
    ...     ]
 
77
    >>>
 
78
    >>>
 
79
    >>> record_arrays = [
 
80
    ...     np.array(PbufferT, dtype=np.dtype(Pdescr).newbyteorder('<')),
 
81
    ...     np.array(NbufferT, dtype=np.dtype(Ndescr).newbyteorder('<')),
 
82
    ...     np.array(PbufferT, dtype=np.dtype(Pdescr).newbyteorder('>')),
 
83
    ...     np.array(NbufferT, dtype=np.dtype(Ndescr).newbyteorder('>')),
 
84
    ... ]
 
85
 
 
86
Test the magic string writing.
 
87
 
 
88
    >>> format.magic(1, 0)
 
89
    '\x93NUMPY\x01\x00'
 
90
    >>> format.magic(0, 0)
 
91
    '\x93NUMPY\x00\x00'
 
92
    >>> format.magic(255, 255)
 
93
    '\x93NUMPY\xff\xff'
 
94
    >>> format.magic(2, 5)
 
95
    '\x93NUMPY\x02\x05'
 
96
 
 
97
Test the magic string reading.
 
98
 
 
99
    >>> format.read_magic(StringIO(format.magic(1, 0)))
 
100
    (1, 0)
 
101
    >>> format.read_magic(StringIO(format.magic(0, 0)))
 
102
    (0, 0)
 
103
    >>> format.read_magic(StringIO(format.magic(255, 255)))
 
104
    (255, 255)
 
105
    >>> format.read_magic(StringIO(format.magic(2, 5)))
 
106
    (2, 5)
 
107
 
 
108
Test the header writing.
 
109
 
 
110
    >>> for arr in basic_arrays + record_arrays:
 
111
    ...     f = StringIO()
 
112
    ...     format.write_array_header_1_0(f, arr)
 
113
    ...     print repr(f.getvalue())
 
114
    ...
 
115
    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (0,)}              \n"
 
116
    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': ()}                \n"
 
117
    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (15,)}             \n"
 
118
    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
119
    "F\x00{'descr': '|u1', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
120
    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
121
    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (0,)}              \n"
 
122
    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': ()}                \n"
 
123
    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (15,)}             \n"
 
124
    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
125
    "F\x00{'descr': '|u1', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
126
    "F\x00{'descr': '|u1', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
127
    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': (0,)}              \n"
 
128
    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': ()}                \n"
 
129
    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': (15,)}             \n"
 
130
    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
131
    "F\x00{'descr': '|i1', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
132
    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
133
    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': (0,)}              \n"
 
134
    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': ()}                \n"
 
135
    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': (15,)}             \n"
 
136
    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
137
    "F\x00{'descr': '|i1', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
138
    "F\x00{'descr': '|i1', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
139
    "F\x00{'descr': '<u2', 'fortran_order': False, 'shape': (0,)}              \n"
 
140
    "F\x00{'descr': '<u2', 'fortran_order': False, 'shape': ()}                \n"
 
141
    "F\x00{'descr': '<u2', 'fortran_order': False, 'shape': (15,)}             \n"
 
142
    "F\x00{'descr': '<u2', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
143
    "F\x00{'descr': '<u2', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
144
    "F\x00{'descr': '<u2', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
145
    "F\x00{'descr': '>u2', 'fortran_order': False, 'shape': (0,)}              \n"
 
146
    "F\x00{'descr': '>u2', 'fortran_order': False, 'shape': ()}                \n"
 
147
    "F\x00{'descr': '>u2', 'fortran_order': False, 'shape': (15,)}             \n"
 
148
    "F\x00{'descr': '>u2', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
149
    "F\x00{'descr': '>u2', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
150
    "F\x00{'descr': '>u2', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
151
    "F\x00{'descr': '<i2', 'fortran_order': False, 'shape': (0,)}              \n"
 
152
    "F\x00{'descr': '<i2', 'fortran_order': False, 'shape': ()}                \n"
 
153
    "F\x00{'descr': '<i2', 'fortran_order': False, 'shape': (15,)}             \n"
 
154
    "F\x00{'descr': '<i2', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
155
    "F\x00{'descr': '<i2', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
156
    "F\x00{'descr': '<i2', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
157
    "F\x00{'descr': '>i2', 'fortran_order': False, 'shape': (0,)}              \n"
 
158
    "F\x00{'descr': '>i2', 'fortran_order': False, 'shape': ()}                \n"
 
159
    "F\x00{'descr': '>i2', 'fortran_order': False, 'shape': (15,)}             \n"
 
160
    "F\x00{'descr': '>i2', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
161
    "F\x00{'descr': '>i2', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
162
    "F\x00{'descr': '>i2', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
163
    "F\x00{'descr': '<u4', 'fortran_order': False, 'shape': (0,)}              \n"
 
164
    "F\x00{'descr': '<u4', 'fortran_order': False, 'shape': ()}                \n"
 
165
    "F\x00{'descr': '<u4', 'fortran_order': False, 'shape': (15,)}             \n"
 
166
    "F\x00{'descr': '<u4', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
167
    "F\x00{'descr': '<u4', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
168
    "F\x00{'descr': '<u4', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
169
    "F\x00{'descr': '>u4', 'fortran_order': False, 'shape': (0,)}              \n"
 
170
    "F\x00{'descr': '>u4', 'fortran_order': False, 'shape': ()}                \n"
 
171
    "F\x00{'descr': '>u4', 'fortran_order': False, 'shape': (15,)}             \n"
 
172
    "F\x00{'descr': '>u4', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
173
    "F\x00{'descr': '>u4', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
174
    "F\x00{'descr': '>u4', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
175
    "F\x00{'descr': '<i4', 'fortran_order': False, 'shape': (0,)}              \n"
 
176
    "F\x00{'descr': '<i4', 'fortran_order': False, 'shape': ()}                \n"
 
177
    "F\x00{'descr': '<i4', 'fortran_order': False, 'shape': (15,)}             \n"
 
178
    "F\x00{'descr': '<i4', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
179
    "F\x00{'descr': '<i4', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
180
    "F\x00{'descr': '<i4', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
181
    "F\x00{'descr': '>i4', 'fortran_order': False, 'shape': (0,)}              \n"
 
182
    "F\x00{'descr': '>i4', 'fortran_order': False, 'shape': ()}                \n"
 
183
    "F\x00{'descr': '>i4', 'fortran_order': False, 'shape': (15,)}             \n"
 
184
    "F\x00{'descr': '>i4', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
185
    "F\x00{'descr': '>i4', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
186
    "F\x00{'descr': '>i4', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
187
    "F\x00{'descr': '<u8', 'fortran_order': False, 'shape': (0,)}              \n"
 
188
    "F\x00{'descr': '<u8', 'fortran_order': False, 'shape': ()}                \n"
 
189
    "F\x00{'descr': '<u8', 'fortran_order': False, 'shape': (15,)}             \n"
 
190
    "F\x00{'descr': '<u8', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
191
    "F\x00{'descr': '<u8', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
192
    "F\x00{'descr': '<u8', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
193
    "F\x00{'descr': '>u8', 'fortran_order': False, 'shape': (0,)}              \n"
 
194
    "F\x00{'descr': '>u8', 'fortran_order': False, 'shape': ()}                \n"
 
195
    "F\x00{'descr': '>u8', 'fortran_order': False, 'shape': (15,)}             \n"
 
196
    "F\x00{'descr': '>u8', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
197
    "F\x00{'descr': '>u8', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
198
    "F\x00{'descr': '>u8', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
199
    "F\x00{'descr': '<i8', 'fortran_order': False, 'shape': (0,)}              \n"
 
200
    "F\x00{'descr': '<i8', 'fortran_order': False, 'shape': ()}                \n"
 
201
    "F\x00{'descr': '<i8', 'fortran_order': False, 'shape': (15,)}             \n"
 
202
    "F\x00{'descr': '<i8', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
203
    "F\x00{'descr': '<i8', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
204
    "F\x00{'descr': '<i8', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
205
    "F\x00{'descr': '>i8', 'fortran_order': False, 'shape': (0,)}              \n"
 
206
    "F\x00{'descr': '>i8', 'fortran_order': False, 'shape': ()}                \n"
 
207
    "F\x00{'descr': '>i8', 'fortran_order': False, 'shape': (15,)}             \n"
 
208
    "F\x00{'descr': '>i8', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
209
    "F\x00{'descr': '>i8', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
210
    "F\x00{'descr': '>i8', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
211
    "F\x00{'descr': '<f4', 'fortran_order': False, 'shape': (0,)}              \n"
 
212
    "F\x00{'descr': '<f4', 'fortran_order': False, 'shape': ()}                \n"
 
213
    "F\x00{'descr': '<f4', 'fortran_order': False, 'shape': (15,)}             \n"
 
214
    "F\x00{'descr': '<f4', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
215
    "F\x00{'descr': '<f4', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
216
    "F\x00{'descr': '<f4', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
217
    "F\x00{'descr': '>f4', 'fortran_order': False, 'shape': (0,)}              \n"
 
218
    "F\x00{'descr': '>f4', 'fortran_order': False, 'shape': ()}                \n"
 
219
    "F\x00{'descr': '>f4', 'fortran_order': False, 'shape': (15,)}             \n"
 
220
    "F\x00{'descr': '>f4', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
221
    "F\x00{'descr': '>f4', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
222
    "F\x00{'descr': '>f4', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
223
    "F\x00{'descr': '<f8', 'fortran_order': False, 'shape': (0,)}              \n"
 
224
    "F\x00{'descr': '<f8', 'fortran_order': False, 'shape': ()}                \n"
 
225
    "F\x00{'descr': '<f8', 'fortran_order': False, 'shape': (15,)}             \n"
 
226
    "F\x00{'descr': '<f8', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
227
    "F\x00{'descr': '<f8', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
228
    "F\x00{'descr': '<f8', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
229
    "F\x00{'descr': '>f8', 'fortran_order': False, 'shape': (0,)}              \n"
 
230
    "F\x00{'descr': '>f8', 'fortran_order': False, 'shape': ()}                \n"
 
231
    "F\x00{'descr': '>f8', 'fortran_order': False, 'shape': (15,)}             \n"
 
232
    "F\x00{'descr': '>f8', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
233
    "F\x00{'descr': '>f8', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
234
    "F\x00{'descr': '>f8', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
235
    "F\x00{'descr': '<c8', 'fortran_order': False, 'shape': (0,)}              \n"
 
236
    "F\x00{'descr': '<c8', 'fortran_order': False, 'shape': ()}                \n"
 
237
    "F\x00{'descr': '<c8', 'fortran_order': False, 'shape': (15,)}             \n"
 
238
    "F\x00{'descr': '<c8', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
239
    "F\x00{'descr': '<c8', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
240
    "F\x00{'descr': '<c8', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
241
    "F\x00{'descr': '>c8', 'fortran_order': False, 'shape': (0,)}              \n"
 
242
    "F\x00{'descr': '>c8', 'fortran_order': False, 'shape': ()}                \n"
 
243
    "F\x00{'descr': '>c8', 'fortran_order': False, 'shape': (15,)}             \n"
 
244
    "F\x00{'descr': '>c8', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
245
    "F\x00{'descr': '>c8', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
246
    "F\x00{'descr': '>c8', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
247
    "F\x00{'descr': '<c16', 'fortran_order': False, 'shape': (0,)}             \n"
 
248
    "F\x00{'descr': '<c16', 'fortran_order': False, 'shape': ()}               \n"
 
249
    "F\x00{'descr': '<c16', 'fortran_order': False, 'shape': (15,)}            \n"
 
250
    "F\x00{'descr': '<c16', 'fortran_order': False, 'shape': (3, 5)}           \n"
 
251
    "F\x00{'descr': '<c16', 'fortran_order': True, 'shape': (5, 3)}            \n"
 
252
    "F\x00{'descr': '<c16', 'fortran_order': False, 'shape': (3, 3)}           \n"
 
253
    "F\x00{'descr': '>c16', 'fortran_order': False, 'shape': (0,)}             \n"
 
254
    "F\x00{'descr': '>c16', 'fortran_order': False, 'shape': ()}               \n"
 
255
    "F\x00{'descr': '>c16', 'fortran_order': False, 'shape': (15,)}            \n"
 
256
    "F\x00{'descr': '>c16', 'fortran_order': False, 'shape': (3, 5)}           \n"
 
257
    "F\x00{'descr': '>c16', 'fortran_order': True, 'shape': (5, 3)}            \n"
 
258
    "F\x00{'descr': '>c16', 'fortran_order': False, 'shape': (3, 3)}           \n"
 
259
    "F\x00{'descr': '|O4', 'fortran_order': False, 'shape': (0,)}              \n"
 
260
    "F\x00{'descr': '|O4', 'fortran_order': False, 'shape': ()}                \n"
 
261
    "F\x00{'descr': '|O4', 'fortran_order': False, 'shape': (15,)}             \n"
 
262
    "F\x00{'descr': '|O4', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
263
    "F\x00{'descr': '|O4', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
264
    "F\x00{'descr': '|O4', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
265
    "F\x00{'descr': '|O4', 'fortran_order': False, 'shape': (0,)}              \n"
 
266
    "F\x00{'descr': '|O4', 'fortran_order': False, 'shape': ()}                \n"
 
267
    "F\x00{'descr': '|O4', 'fortran_order': False, 'shape': (15,)}             \n"
 
268
    "F\x00{'descr': '|O4', 'fortran_order': False, 'shape': (3, 5)}            \n"
 
269
    "F\x00{'descr': '|O4', 'fortran_order': True, 'shape': (5, 3)}             \n"
 
270
    "F\x00{'descr': '|O4', 'fortran_order': False, 'shape': (3, 3)}            \n"
 
271
    "v\x00{'descr': [('x', '<i4', (2,)), ('y', '<f8', (2, 2)), ('z', '|u1')],\n 'fortran_order': False,\n 'shape': (2,)}         \n"
 
272
    "\x16\x02{'descr': [('x', '<i4', (2,)),\n           ('Info',\n            [('value', '<c16'),\n             ('y2', '<f8'),\n             ('Info2',\n              [('name', '|S2'),\n               ('value', '<c16', (2,)),\n               ('y3', '<f8', (2,)),\n               ('z3', '<u4', (2,))]),\n             ('name', '|S2'),\n             ('z2', '|b1')]),\n           ('color', '|S2'),\n           ('info', [('Name', '<U8'), ('Value', '<c16')]),\n           ('y', '<f8', (2, 2)),\n           ('z', '|u1')],\n 'fortran_order': False,\n 'shape': (2,)}      \n"
 
273
    "v\x00{'descr': [('x', '>i4', (2,)), ('y', '>f8', (2, 2)), ('z', '|u1')],\n 'fortran_order': False,\n 'shape': (2,)}         \n"
 
274
    "\x16\x02{'descr': [('x', '>i4', (2,)),\n           ('Info',\n            [('value', '>c16'),\n             ('y2', '>f8'),\n             ('Info2',\n              [('name', '|S2'),\n               ('value', '>c16', (2,)),\n               ('y3', '>f8', (2,)),\n               ('z3', '>u4', (2,))]),\n             ('name', '|S2'),\n             ('z2', '|b1')]),\n           ('color', '|S2'),\n           ('info', [('Name', '>U8'), ('Value', '>c16')]),\n           ('y', '>f8', (2, 2)),\n           ('z', '|u1')],\n 'fortran_order': False,\n 'shape': (2,)}      \n"
 
275
'''
 
276
 
 
277
 
 
278
from cStringIO import StringIO
 
279
import os
 
280
import shutil
 
281
import tempfile
 
282
 
 
283
import numpy as np
 
284
from numpy.testing import assert_array_equal, raises
 
285
 
 
286
from numpy.lib import format
 
287
 
 
288
 
 
289
tempdir = None
 
290
 
 
291
# Module-level setup.
 
292
def setup_module():
 
293
    global tempdir
 
294
    tempdir = tempfile.mkdtemp()
 
295
 
 
296
def teardown_module():
 
297
    global tempdir
 
298
    if tempdir is not None and os.path.isdir(tempdir):
 
299
        shutil.rmtree(tempdir)
 
300
        tempdir = None
 
301
 
 
302
 
 
303
# Generate some basic arrays to test with.
 
304
scalars = [
 
305
    np.uint8,
 
306
    np.int8,
 
307
    np.uint16,
 
308
    np.int16,
 
309
    np.uint32,
 
310
    np.int32,
 
311
    np.uint64,
 
312
    np.int64,
 
313
    np.float32,
 
314
    np.float64,
 
315
    np.complex64,
 
316
    np.complex128,
 
317
    object,
 
318
]
 
319
basic_arrays = []
 
320
for scalar in scalars:
 
321
    for endian in '<>':
 
322
        dtype = np.dtype(scalar).newbyteorder(endian)
 
323
        basic = np.arange(15).astype(dtype)
 
324
        basic_arrays.extend([
 
325
            # Empty
 
326
            np.array([], dtype=dtype),
 
327
            # Rank-0
 
328
            np.array(10, dtype=dtype),
 
329
            # 1-D
 
330
            basic,
 
331
            # 2-D C-contiguous
 
332
            basic.reshape((3,5)),
 
333
            # 2-D F-contiguous
 
334
            basic.reshape((3,5)).T,
 
335
            # 2-D non-contiguous
 
336
            basic.reshape((3,5))[::-1,::2],
 
337
        ])
 
338
 
 
339
# More complicated record arrays.
 
340
# This is the structure of the table used for plain objects:
 
341
#
 
342
# +-+-+-+
 
343
# |x|y|z|
 
344
# +-+-+-+
 
345
 
 
346
# Structure of a plain array description:
 
347
Pdescr = [
 
348
    ('x', 'i4', (2,)),
 
349
    ('y', 'f8', (2, 2)),
 
350
    ('z', 'u1')]
 
351
 
 
352
# A plain list of tuples with values for testing:
 
353
PbufferT = [
 
354
    # x     y                  z
 
355
    ([3,2], [[6.,4.],[6.,4.]], 8),
 
356
    ([4,3], [[7.,5.],[7.,5.]], 9),
 
357
    ]
 
358
 
 
359
 
 
360
# This is the structure of the table used for nested objects (DON'T PANIC!):
 
361
#
 
362
# +-+---------------------------------+-----+----------+-+-+
 
363
# |x|Info                             |color|info      |y|z|
 
364
# | +-----+--+----------------+----+--+     +----+-----+ | |
 
365
# | |value|y2|Info2           |name|z2|     |Name|Value| | |
 
366
# | |     |  +----+-----+--+--+    |  |     |    |     | | |
 
367
# | |     |  |name|value|y3|z3|    |  |     |    |     | | |
 
368
# +-+-----+--+----+-----+--+--+----+--+-----+----+-----+-+-+
 
369
#
 
370
 
 
371
# The corresponding nested array description:
 
372
Ndescr = [
 
373
    ('x', 'i4', (2,)),
 
374
    ('Info', [
 
375
        ('value', 'c16'),
 
376
        ('y2', 'f8'),
 
377
        ('Info2', [
 
378
            ('name', 'S2'),
 
379
            ('value', 'c16', (2,)),
 
380
            ('y3', 'f8', (2,)),
 
381
            ('z3', 'u4', (2,))]),
 
382
        ('name', 'S2'),
 
383
        ('z2', 'b1')]),
 
384
    ('color', 'S2'),
 
385
    ('info', [
 
386
        ('Name', 'U8'),
 
387
        ('Value', 'c16')]),
 
388
    ('y', 'f8', (2, 2)),
 
389
    ('z', 'u1')]
 
390
 
 
391
NbufferT = [
 
392
    # x     Info                                                color info        y                  z
 
393
    #       value y2 Info2                            name z2         Name Value
 
394
    #                name   value    y3       z3
 
395
    ([3,2], (6j, 6., ('nn', [6j,4j], [6.,4.], [1,2]), 'NN', True), 'cc', ('NN', 6j), [[6.,4.],[6.,4.]], 8),
 
396
    ([4,3], (7j, 7., ('oo', [7j,5j], [7.,5.], [2,1]), 'OO', False), 'dd', ('OO', 7j), [[7.,5.],[7.,5.]], 9),
 
397
    ]
 
398
 
 
399
record_arrays = [
 
400
    np.array(PbufferT, dtype=np.dtype(Pdescr).newbyteorder('<')),
 
401
    np.array(NbufferT, dtype=np.dtype(Ndescr).newbyteorder('<')),
 
402
    np.array(PbufferT, dtype=np.dtype(Pdescr).newbyteorder('>')),
 
403
    np.array(NbufferT, dtype=np.dtype(Ndescr).newbyteorder('>')),
 
404
]
 
405
 
 
406
def roundtrip(arr):
 
407
    f = StringIO()
 
408
    format.write_array(f, arr)
 
409
    f2 = StringIO(f.getvalue())
 
410
    arr2 = format.read_array(f2)
 
411
    return arr2
 
412
 
 
413
def assert_equal(o1, o2):
 
414
    assert o1 == o2
 
415
 
 
416
 
 
417
def test_roundtrip():
 
418
    for arr in basic_arrays + record_arrays:
 
419
        arr2 = roundtrip(arr)
 
420
        yield assert_array_equal, arr, arr2
 
421
 
 
422
def test_memmap_roundtrip():
 
423
    for arr in basic_arrays + record_arrays:
 
424
        if arr.dtype.hasobject:
 
425
            # Skip these since they can't be mmap'ed.
 
426
            continue
 
427
        # Write it out normally and through mmap.
 
428
        nfn = os.path.join(tempdir, 'normal.npy')
 
429
        mfn = os.path.join(tempdir, 'memmap.npy')
 
430
        fp = open(nfn, 'wb')
 
431
        try:
 
432
            format.write_array(fp, arr)
 
433
        finally:
 
434
            fp.close()
 
435
 
 
436
        fortran_order = (arr.flags.f_contiguous and not arr.flags.c_contiguous)
 
437
        ma = format.open_memmap(mfn, mode='w+', dtype=arr.dtype,
 
438
            shape=arr.shape, fortran_order=fortran_order)
 
439
        ma[...] = arr
 
440
        del ma
 
441
 
 
442
        # Check that both of these files' contents are the same.
 
443
        fp = open(nfn, 'rb')
 
444
        normal_bytes = fp.read()
 
445
        fp.close()
 
446
        fp = open(mfn, 'rb')
 
447
        memmap_bytes = fp.read()
 
448
        fp.close()
 
449
        yield assert_equal, normal_bytes, memmap_bytes
 
450
 
 
451
        # Check that reading the file using memmap works.
 
452
        ma = format.open_memmap(nfn, mode='r')
 
453
        yield assert_array_equal, ma, arr
 
454
        del ma
 
455
 
 
456
 
 
457
def test_write_version_1_0():
 
458
    f = StringIO()
 
459
    arr = np.arange(1)
 
460
    # These should pass.
 
461
    format.write_array(f, arr, version=(1, 0))
 
462
    format.write_array(f, arr)
 
463
 
 
464
    # These should all fail.
 
465
    bad_versions = [
 
466
        (1, 1),
 
467
        (0, 0),
 
468
        (0, 1),
 
469
        (2, 0),
 
470
        (2, 2),
 
471
        (255, 255),
 
472
    ]
 
473
    for version in bad_versions:
 
474
        try:
 
475
            format.write_array(f, arr, version=version)
 
476
        except ValueError:
 
477
            pass
 
478
        else:
 
479
            raise AssertionError("we should have raised a ValueError for the bad version %r" % (version,))
 
480
 
 
481
 
 
482
bad_version_magic = [
 
483
    '\x93NUMPY\x01\x01',
 
484
    '\x93NUMPY\x00\x00',
 
485
    '\x93NUMPY\x00\x01',
 
486
    '\x93NUMPY\x02\x00',
 
487
    '\x93NUMPY\x02\x02',
 
488
    '\x93NUMPY\xff\xff',
 
489
]
 
490
malformed_magic = [
 
491
    '\x92NUMPY\x01\x00',
 
492
    '\x00NUMPY\x01\x00',
 
493
    '\x93numpy\x01\x00',
 
494
    '\x93MATLB\x01\x00',
 
495
    '\x93NUMPY\x01',
 
496
    '\x93NUMPY',
 
497
    '',
 
498
]
 
499
 
 
500
def test_read_magic_bad_magic():
 
501
    for magic in malformed_magic:
 
502
        f = StringIO(magic)
 
503
        yield raises(ValueError)(format.read_magic), f
 
504
 
 
505
def test_read_version_1_0_bad_magic():
 
506
    for magic in bad_version_magic + malformed_magic:
 
507
        f = StringIO(magic)
 
508
        yield raises(ValueError)(format.read_array), f