← Back to branch summary

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

« back to all changes in this revision

Viewing changes to numpy/ma/timer_comparison.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/ma/timer_comparison.py
 
1
 
 
2
import timeit
 
3
 
 
4
import numpy
 
5
from numpy import int_, float_, bool_
 
6
import numpy.core.fromnumeric as fromnumeric
 
7
 
 
8
from numpy.testing.utils import build_err_msg, rand
 
9
 
 
10
 
 
11
numpy.seterr(all='ignore')
 
12
 
 
13
pi = numpy.pi
 
14
 
 
15
class moduletester:
 
16
    #-----------------------------------
 
17
    def __init__(self, module):
 
18
        self.module = module
 
19
        self.allequal = module.allequal
 
20
        self.arange = module.arange
 
21
        self.array = module.array
 
22
#        self.average =  module.average
 
23
        self.concatenate = module.concatenate
 
24
        self.count = module.count
 
25
        self.equal = module.equal
 
26
        self.filled = module.filled
 
27
        self.getmask = module.getmask
 
28
        self.getmaskarray = module.getmaskarray
 
29
        self.id = id
 
30
        self.inner = module.inner
 
31
        self.make_mask = module.make_mask
 
32
        self.masked = module.masked
 
33
        self.masked_array = module.masked_array
 
34
        self.masked_values = module.masked_values
 
35
        self.mask_or = module.mask_or
 
36
        self.nomask = module.nomask
 
37
        self.ones = module.ones
 
38
        self.outer = module.outer
 
39
        self.repeat = module.repeat
 
40
        self.resize = module.resize
 
41
        self.sort = module.sort
 
42
        self.take = module.take
 
43
        self.transpose = module.transpose
 
44
        self.zeros = module.zeros
 
45
        self.MaskType = module.MaskType
 
46
        try:
 
47
            self.umath = module.umath
 
48
        except AttributeError:
 
49
            self.umath = module.core.umath
 
50
        self.testnames = []
 
51
    #........................
 
52
    def assert_array_compare(self, comparison, x, y, err_msg='', header='',
 
53
                         fill_value=True):
 
54
        """Asserts that a comparison relation between two masked arrays is satisfied
 
55
        elementwise."""
 
56
        xf = self.filled(x)
 
57
        yf = self.filled(y)
 
58
        m = self.mask_or(self.getmask(x), self.getmask(y))
 
59
 
 
60
        x = self.filled(self.masked_array(xf, mask=m), fill_value)
 
61
        y = self.filled(self.masked_array(yf, mask=m), fill_value)
 
62
        if (x.dtype.char != "O"):
 
63
            x = x.astype(float_)
 
64
            if isinstance(x, numpy.ndarray) and x.size > 1:
 
65
                x[numpy.isnan(x)] = 0
 
66
            elif numpy.isnan(x):
 
67
                x = 0
 
68
        if (y.dtype.char != "O"):
 
69
            y = y.astype(float_)
 
70
            if isinstance(y, numpy.ndarray) and y.size > 1:
 
71
                y[numpy.isnan(y)] = 0
 
72
            elif numpy.isnan(y):
 
73
                y = 0
 
74
        try:
 
75
            cond = (x.shape==() or y.shape==()) or x.shape == y.shape
 
76
            if not cond:
 
77
                msg = build_err_msg([x, y],
 
78
                                    err_msg
 
79
                                    + '\n(shapes %s, %s mismatch)' % (x.shape,
 
80
                                                                      y.shape),
 
81
                                    header=header,
 
82
                                    names=('x', 'y'))
 
83
                assert cond, msg
 
84
            val = comparison(x,y)
 
85
            if m is not self.nomask and fill_value:
 
86
                val = self.masked_array(val, mask=m)
 
87
            if isinstance(val, bool):
 
88
                cond = val
 
89
                reduced = [0]
 
90
            else:
 
91
                reduced = val.ravel()
 
92
                cond = reduced.all()
 
93
                reduced = reduced.tolist()
 
94
            if not cond:
 
95
                match = 100-100.0*reduced.count(1)/len(reduced)
 
96
                msg = build_err_msg([x, y],
 
97
                                    err_msg
 
98
                                    + '\n(mismatch %s%%)' % (match,),
 
99
                                    header=header,
 
100
                                    names=('x', 'y'))
 
101
                assert cond, msg
 
102
        except ValueError:
 
103
            msg = build_err_msg([x, y], err_msg, header=header, names=('x', 'y'))
 
104
            raise ValueError(msg)
 
105
    #............................
 
106
    def assert_array_equal(self, x, y, err_msg=''):
 
107
        """Checks the elementwise equality of two masked arrays."""
 
108
        self.assert_array_compare(self.equal, x, y, err_msg=err_msg,
 
109
                                  header='Arrays are not equal')
 
110
    #----------------------------------
 
111
    def test_0(self):
 
112
        "Tests creation"
 
113
        x = numpy.array([1.,1.,1.,-2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
 
114
        m = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
 
115
        xm = self.masked_array(x, mask=m)
 
116
        xm[0]
 
117
    #----------------------------------
 
118
    def test_1(self):
 
119
        "Tests creation"
 
120
        x = numpy.array([1.,1.,1.,-2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
 
121
        y = numpy.array([5.,0.,3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
 
122
        a10 = 10.
 
123
        m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
 
124
        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0 ,0, 1]
 
125
        xm = self.masked_array(x, mask=m1)
 
126
        ym = self.masked_array(y, mask=m2)
 
127
        z = numpy.array([-.5, 0., .5, .8])
 
128
        zm = self.masked_array(z, mask=[0,1,0,0])
 
129
        xf = numpy.where(m1, 1.e+20, x)
 
130
        xm.set_fill_value(1.e+20)
 
131
        #.....
 
132
        assert((xm-ym).filled(0).any())
 
133
        #fail_if_equal(xm.mask.astype(int_), ym.mask.astype(int_))
 
134
        s = x.shape
 
135
        assert(xm.size == reduce(lambda x,y:x*y, s))
 
136
        assert(self.count(xm) == len(m1) - reduce(lambda x,y:x+y, m1))
 
137
        #.....
 
138
        for s in [(4,3), (6,2)]:
 
139
            x.shape = s
 
140
            y.shape = s
 
141
            xm.shape = s
 
142
            ym.shape = s
 
143
            xf.shape = s
 
144
 
 
145
            assert(self.count(xm) == len(m1) - reduce(lambda x,y:x+y, m1))
 
146
    #----------------------------------
 
147
    def test_2(self):
 
148
        "Tests conversions and indexing"
 
149
        x1 = numpy.array([1,2,4,3])
 
150
        x2 = self.array(x1, mask=[1,0,0,0])
 
151
        x3 = self.array(x1, mask=[0,1,0,1])
 
152
        x4 = self.array(x1)
 
153
    # test conversion to strings
 
154
        junk, garbage = str(x2), repr(x2)
 
155
#        assert_equal(numpy.sort(x1), self.sort(x2, fill_value=0))
 
156
    # tests of indexing
 
157
        assert type(x2[1]) is type(x1[1])
 
158
        assert x1[1] == x2[1]
 
159
#        assert self.allequal(x1[2],x2[2])
 
160
#        assert self.allequal(x1[2:5],x2[2:5])
 
161
#        assert self.allequal(x1[:],x2[:])
 
162
#        assert self.allequal(x1[1:], x3[1:])
 
163
        x1[2] = 9
 
164
        x2[2] = 9
 
165
        self.assert_array_equal(x1,x2)
 
166
        x1[1:3] = 99
 
167
        x2[1:3] = 99
 
168
#        assert self.allequal(x1,x2)
 
169
        x2[1] = self.masked
 
170
#        assert self.allequal(x1,x2)
 
171
        x2[1:3] = self.masked
 
172
#        assert self.allequal(x1,x2)
 
173
        x2[:] = x1
 
174
        x2[1] = self.masked
 
175
#        assert self.allequal(self.getmask(x2),self.array([0,1,0,0]))
 
176
        x3[:] = self.masked_array([1,2,3,4],[0,1,1,0])
 
177
#        assert self.allequal(self.getmask(x3), self.array([0,1,1,0]))
 
178
        x4[:] = self.masked_array([1,2,3,4],[0,1,1,0])
 
179
#        assert self.allequal(self.getmask(x4), self.array([0,1,1,0]))
 
180
#        assert self.allequal(x4, self.array([1,2,3,4]))
 
181
        x1 = numpy.arange(5)*1.0
 
182
        x2 = self.masked_values(x1, 3.0)
 
183
#        assert self.allequal(x1,x2)
 
184
#        assert self.allequal(self.array([0,0,0,1,0], self.MaskType), x2.mask)
 
185
        x1 = self.array([1,'hello',2,3],object)
 
186
        x2 = numpy.array([1,'hello',2,3],object)
 
187
        s1 = x1[1]
 
188
        s2 = x2[1]
 
189
        assert x1[1:1].shape == (0,)
 
190
        # Tests copy-size
 
191
        n = [0,0,1,0,0]
 
192
        m = self.make_mask(n)
 
193
        m2 = self.make_mask(m)
 
194
        assert(m is m2)
 
195
        m3 = self.make_mask(m, copy=1)
 
196
        assert(m is not m3)
 
197
 
 
198
    #----------------------------------
 
199
    def test_3(self):
 
200
        "Tests resize/repeat"
 
201
        x4 = self.arange(4)
 
202
        x4[2] = self.masked
 
203
        y4 = self.resize(x4, (8,))
 
204
        assert self.allequal(self.concatenate([x4,x4]), y4)
 
205
        assert self.allequal(self.getmask(y4),[0,0,1,0,0,0,1,0])
 
206
        y5 = self.repeat(x4, (2,2,2,2), axis=0)
 
207
        self.assert_array_equal(y5, [0,0,1,1,2,2,3,3])
 
208
        y6 = self.repeat(x4, 2, axis=0)
 
209
        assert self.allequal(y5, y6)
 
210
        y7 = x4.repeat((2,2,2,2), axis=0)
 
211
        assert self.allequal(y5,y7)
 
212
        y8 = x4.repeat(2,0)
 
213
        assert self.allequal(y5,y8)
 
214
 
 
215
    #----------------------------------
 
216
    def test_4(self):
 
217
        "Test of take, transpose, inner, outer products"
 
218
        x = self.arange(24)
 
219
        y = numpy.arange(24)
 
220
        x[5:6] = self.masked
 
221
        x = x.reshape(2,3,4)
 
222
        y = y.reshape(2,3,4)
 
223
        assert self.allequal(numpy.transpose(y,(2,0,1)), self.transpose(x,(2,0,1)))
 
224
        assert self.allequal(numpy.take(y, (2,0,1), 1), self.take(x, (2,0,1), 1))
 
225
        assert self.allequal(numpy.inner(self.filled(x,0), self.filled(y,0)),
 
226
                            self.inner(x, y))
 
227
        assert self.allequal(numpy.outer(self.filled(x,0), self.filled(y,0)),
 
228
                            self.outer(x, y))
 
229
        y = self.array(['abc', 1, 'def', 2, 3], object)
 
230
        y[2] = self.masked
 
231
        t = self.take(y,[0,3,4])
 
232
        assert t[0] == 'abc'
 
233
        assert t[1] == 2
 
234
        assert t[2] == 3
 
235
    #----------------------------------
 
236
    def test_5(self):
 
237
        "Tests inplace w/ scalar"
 
238
 
 
239
        x = self.arange(10)
 
240
        y = self.arange(10)
 
241
        xm = self.arange(10)
 
242
        xm[2] = self.masked
 
243
        x += 1
 
244
        assert self.allequal(x, y+1)
 
245
        xm += 1
 
246
        assert self.allequal(xm, y+1)
 
247
 
 
248
        x = self.arange(10)
 
249
        xm = self.arange(10)
 
250
        xm[2] = self.masked
 
251
        x -= 1
 
252
        assert self.allequal(x, y-1)
 
253
        xm -= 1
 
254
        assert self.allequal(xm, y-1)
 
255
 
 
256
        x = self.arange(10)*1.0
 
257
        xm = self.arange(10)*1.0
 
258
        xm[2] = self.masked
 
259
        x *= 2.0
 
260
        assert self.allequal(x, y*2)
 
261
        xm *= 2.0
 
262
        assert self.allequal(xm, y*2)
 
263
 
 
264
        x = self.arange(10)*2
 
265
        xm = self.arange(10)*2
 
266
        xm[2] = self.masked
 
267
        x /= 2
 
268
        assert self.allequal(x, y)
 
269
        xm /= 2
 
270
        assert self.allequal(xm, y)
 
271
 
 
272
        x = self.arange(10)*1.0
 
273
        xm = self.arange(10)*1.0
 
274
        xm[2] = self.masked
 
275
        x /= 2.0
 
276
        assert self.allequal(x, y/2.0)
 
277
        xm /= self.arange(10)
 
278
        self.assert_array_equal(xm, self.ones((10,)))
 
279
 
 
280
        x = self.arange(10).astype(float_)
 
281
        xm = self.arange(10)
 
282
        xm[2] = self.masked
 
283
        id1 = self.id(x.raw_data())
 
284
        x += 1.
 
285
        #assert id1 == self.id(x.raw_data())
 
286
        assert self.allequal(x, y+1.)
 
287
 
 
288
 
 
289
    def test_6(self):
 
290
        "Tests inplace w/ array"
 
291
 
 
292
        x = self.arange(10, dtype=float_)
 
293
        y = self.arange(10)
 
294
        xm = self.arange(10, dtype=float_)
 
295
        xm[2] = self.masked
 
296
        m = xm.mask
 
297
        a = self.arange(10, dtype=float_)
 
298
        a[-1] = self.masked
 
299
        x += a
 
300
        xm += a
 
301
        assert self.allequal(x,y+a)
 
302
        assert self.allequal(xm,y+a)
 
303
        assert self.allequal(xm.mask, self.mask_or(m,a.mask))
 
304
 
 
305
        x = self.arange(10, dtype=float_)
 
306
        xm = self.arange(10, dtype=float_)
 
307
        xm[2] = self.masked
 
308
        m = xm.mask
 
309
        a = self.arange(10, dtype=float_)
 
310
        a[-1] = self.masked
 
311
        x -= a
 
312
        xm -= a
 
313
        assert self.allequal(x,y-a)
 
314
        assert self.allequal(xm,y-a)
 
315
        assert self.allequal(xm.mask, self.mask_or(m,a.mask))
 
316
 
 
317
        x = self.arange(10, dtype=float_)
 
318
        xm = self.arange(10, dtype=float_)
 
319
        xm[2] = self.masked
 
320
        m = xm.mask
 
321
        a = self.arange(10, dtype=float_)
 
322
        a[-1] = self.masked
 
323
        x *= a
 
324
        xm *= a
 
325
        assert self.allequal(x,y*a)
 
326
        assert self.allequal(xm,y*a)
 
327
        assert self.allequal(xm.mask, self.mask_or(m,a.mask))
 
328
 
 
329
        x = self.arange(10, dtype=float_)
 
330
        xm = self.arange(10, dtype=float_)
 
331
        xm[2] = self.masked
 
332
        m = xm.mask
 
333
        a = self.arange(10, dtype=float_)
 
334
        a[-1] = self.masked
 
335
        x /= a
 
336
        xm /= a
 
337
 
 
338
    #----------------------------------
 
339
    def test_7(self):
 
340
        "Tests ufunc"
 
341
        d = (self.array([1.0, 0, -1, pi/2]*2, mask=[0,1]+[0]*6),
 
342
             self.array([1.0, 0, -1, pi/2]*2, mask=[1,0]+[0]*6),)
 
343
        for f in ['sqrt', 'log', 'log10', 'exp', 'conjugate',
 
344
#                  'sin', 'cos', 'tan',
 
345
#                  'arcsin', 'arccos', 'arctan',
 
346
#                  'sinh', 'cosh', 'tanh',
 
347
#                  'arcsinh',
 
348
#                  'arccosh',
 
349
#                  'arctanh',
 
350
#                  'absolute', 'fabs', 'negative',
 
351
#                  # 'nonzero', 'around',
 
352
#                  'floor', 'ceil',
 
353
#                  # 'sometrue', 'alltrue',
 
354
#                  'logical_not',
 
355
#                  'add', 'subtract', 'multiply',
 
356
#                  'divide', 'true_divide', 'floor_divide',
 
357
#                  'remainder', 'fmod', 'hypot', 'arctan2',
 
358
#                  'equal', 'not_equal', 'less_equal', 'greater_equal',
 
359
#                  'less', 'greater',
 
360
#                  'logical_and', 'logical_or', 'logical_xor',
 
361
                  ]:
 
362
            #print f
 
363
            try:
 
364
                uf = getattr(self.umath, f)
 
365
            except AttributeError:
 
366
                uf = getattr(fromnumeric, f)
 
367
            mf = getattr(self.module, f)
 
368
            args = d[:uf.nin]
 
369
            ur = uf(*args)
 
370
            mr = mf(*args)
 
371
            self.assert_array_equal(ur.filled(0), mr.filled(0), f)
 
372
            self.assert_array_equal(ur._mask, mr._mask)
 
373
 
 
374
    #----------------------------------
 
375
    def test_99(self):
 
376
        # test average
 
377
        ott = self.array([0.,1.,2.,3.], mask=[1,0,0,0])
 
378
        self.assert_array_equal(2.0, self.average(ott,axis=0))
 
379
        self.assert_array_equal(2.0, self.average(ott, weights=[1., 1., 2., 1.]))
 
380
        result, wts = self.average(ott, weights=[1.,1.,2.,1.], returned=1)
 
381
        self.assert_array_equal(2.0, result)
 
382
        assert(wts == 4.0)
 
383
        ott[:] = self.masked
 
384
        assert(self.average(ott,axis=0) is self.masked)
 
385
        ott = self.array([0.,1.,2.,3.], mask=[1,0,0,0])
 
386
        ott = ott.reshape(2,2)
 
387
        ott[:,1] = self.masked
 
388
        self.assert_array_equal(self.average(ott,axis=0), [2.0, 0.0])
 
389
        assert(self.average(ott,axis=1)[0] is self.masked)
 
390
        self.assert_array_equal([2.,0.], self.average(ott, axis=0))
 
391
        result, wts = self.average(ott, axis=0, returned=1)
 
392
        self.assert_array_equal(wts, [1., 0.])
 
393
        w1 = [0,1,1,1,1,0]
 
394
        w2 = [[0,1,1,1,1,0],[1,0,0,0,0,1]]
 
395
        x = self.arange(6)
 
396
        self.assert_array_equal(self.average(x, axis=0), 2.5)
 
397
        self.assert_array_equal(self.average(x, axis=0, weights=w1), 2.5)
 
398
        y = self.array([self.arange(6), 2.0*self.arange(6)])
 
399
        self.assert_array_equal(self.average(y, None), numpy.add.reduce(numpy.arange(6))*3./12.)
 
400
        self.assert_array_equal(self.average(y, axis=0), numpy.arange(6) * 3./2.)
 
401
        self.assert_array_equal(self.average(y, axis=1), [self.average(x,axis=0), self.average(x,axis=0) * 2.0])
 
402
        self.assert_array_equal(self.average(y, None, weights=w2), 20./6.)
 
403
        self.assert_array_equal(self.average(y, axis=0, weights=w2), [0.,1.,2.,3.,4.,10.])
 
404
        self.assert_array_equal(self.average(y, axis=1), [self.average(x,axis=0), self.average(x,axis=0) * 2.0])
 
405
        m1 = self.zeros(6)
 
406
        m2 = [0,0,1,1,0,0]
 
407
        m3 = [[0,0,1,1,0,0],[0,1,1,1,1,0]]
 
408
        m4 = self.ones(6)
 
409
        m5 = [0, 1, 1, 1, 1, 1]
 
410
        self.assert_array_equal(self.average(self.masked_array(x, m1),axis=0), 2.5)
 
411
        self.assert_array_equal(self.average(self.masked_array(x, m2),axis=0), 2.5)
 
412
    #    assert(self.average(masked_array(x, m4),axis=0) is masked)
 
413
        self.assert_array_equal(self.average(self.masked_array(x, m5),axis=0), 0.0)
 
414
        self.assert_array_equal(self.count(self.average(self.masked_array(x, m4),axis=0)), 0)
 
415
        z = self.masked_array(y, m3)
 
416
        self.assert_array_equal(self.average(z, None), 20./6.)
 
417
        self.assert_array_equal(self.average(z, axis=0), [0.,1.,99.,99.,4.0, 7.5])
 
418
        self.assert_array_equal(self.average(z, axis=1), [2.5, 5.0])
 
419
        self.assert_array_equal(self.average(z,axis=0, weights=w2), [0.,1., 99., 99., 4.0, 10.0])
 
420
    #------------------------
 
421
    def test_A(self):
 
422
        x = self.arange(24)
 
423
        y = numpy.arange(24)
 
424
        x[5:6] = self.masked
 
425
        x = x.reshape(2,3,4)
 
426
 
 
427
 
 
428
################################################################################
 
429
if __name__ == '__main__':
 
430
 
 
431
    setup_base = "from __main__ import moduletester \n"\
 
432
                 "import numpy\n" \
 
433
                 "tester = moduletester(module)\n"
 
434
#    setup_new = "import numpy.ma.core_ini as module\n"+setup_base
 
435
    setup_cur = "import numpy.ma.core as module\n"+setup_base
 
436
#    setup_alt = "import numpy.ma.core_alt as module\n"+setup_base
 
437
#    setup_tmp = "import numpy.ma.core_tmp as module\n"+setup_base
 
438
 
 
439
    (nrepeat, nloop) = (10, 10)
 
440
 
 
441
    if 1:
 
442
        for i in range(1,8):
 
443
            func = 'tester.test_%i()' % i
 
444
#            new = timeit.Timer(func, setup_new).repeat(nrepeat, nloop*10)
 
445
            cur = timeit.Timer(func, setup_cur).repeat(nrepeat, nloop*10)
 
446
#            alt = timeit.Timer(func, setup_alt).repeat(nrepeat, nloop*10)
 
447
#            tmp = timeit.Timer(func, setup_tmp).repeat(nrepeat, nloop*10)
 
448
#            new = numpy.sort(new)
 
449
            cur = numpy.sort(cur)
 
450
#            alt = numpy.sort(alt)
 
451
#            tmp = numpy.sort(tmp)
 
452
            print "#%i" % i +50*'.'
 
453
            print eval("moduletester.test_%i.__doc__" % i)
 
454
#            print "core_ini     : %.3f - %.3f" % (new[0], new[1])
 
455
            print "core_current : %.3f - %.3f" % (cur[0], cur[1])
 
456
#            print "core_alt     : %.3f - %.3f" % (alt[0], alt[1])
 
457
#            print "core_tmp     : %.3f - %.3f" % (tmp[0], tmp[1])