← Back to branch summary

~ubuntu-branches/ubuntu/feisty/python-numpy/feisty

« back to all changes in this revision

Viewing changes to numpy/core/tests/test_ma.py

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2006-07-12 10:00:24 UTC
  • Revision ID: james.westby@ubuntu.com-20060712100024-5lw9q2yczlisqcrt
Tags: upstream-0.9.8
Import upstream version 0.9.8

Show diffs side-by-side

added added

removed removed

Lines of Context:
numpy/core/tests/test_ma.py
 
1
import numpy
 
2
import types, time
 
3
from numpy.core.ma import *
 
4
from numpy.core.numerictypes import float32
 
5
from numpy.testing import ScipyTestCase, ScipyTest
 
6
pi = numpy.pi
 
7
def eq(v,w, msg=''):
 
8
    result = allclose(v,w)
 
9
    if not result:
 
10
        print """Not eq:%s
 
11
%s
 
12
----
 
13
%s"""% (msg, str(v), str(w))
 
14
    return result
 
15
 
 
16
class test_ma(ScipyTestCase):
 
17
    def __init__(self, *args, **kwds):
 
18
        ScipyTestCase.__init__(self, *args, **kwds)
 
19
        self.setUp()
 
20
 
 
21
    def setUp (self):
 
22
        x=numpy.array([1.,1.,1.,-2., pi/2.0, 4., 5., -10., 10., 1., 2., 3.])
 
23
        y=numpy.array([5.,0.,3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])
 
24
        a10 = 10.
 
25
        m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
 
26
        m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0 ,0, 1]
 
27
        xm = array(x, mask=m1)
 
28
        ym = array(y, mask=m2)
 
29
        z = numpy.array([-.5, 0., .5, .8])
 
30
        zm = array(z, mask=[0,1,0,0])
 
31
        xf = numpy.where(m1, 1.e+20, x)
 
32
        s = x.shape
 
33
        xm.set_fill_value(1.e+20)
 
34
        self.d = (x, y, a10, m1, m2, xm, ym, z, zm, xf, s)
 
35
 
 
36
    def check_testBasic1d(self):
 
37
        "Test of basic array creation and properties in 1 dimension."
 
38
        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
 
39
        self.failIf(isMaskedArray(x))
 
40
        self.failUnless(isMaskedArray(xm))
 
41
        self.assertEqual(shape(xm), s)
 
42
        self.assertEqual(xm.shape, s)
 
43
        self.assertEqual(xm.dtype, x.dtype)
 
44
        self.assertEqual( xm.size , reduce(lambda x,y:x*y, s))
 
45
        self.assertEqual(count(xm) , len(m1) - reduce(lambda x,y:x+y, m1))
 
46
        self.failUnless(eq(xm, xf))
 
47
        self.failUnless(eq(filled(xm, 1.e20), xf))
 
48
        self.failUnless(eq(x, xm))
 
49
 
 
50
    def check_testBasic2d(self):
 
51
        "Test of basic array creation and properties in 2 dimensions."
 
52
        for s in [(4,3), (6,2)]:
 
53
            (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
 
54
            x.shape = s
 
55
            y.shape = s
 
56
            xm.shape = s
 
57
            ym.shape = s
 
58
            xf.shape = s
 
59
 
 
60
            self.failIf(isMaskedArray(x))
 
61
            self.failUnless(isMaskedArray(xm))
 
62
            self.assertEqual(shape(xm), s)
 
63
            self.assertEqual(xm.shape, s)
 
64
            self.assertEqual( xm.size , reduce(lambda x,y:x*y, s))
 
65
            self.assertEqual( count(xm) , len(m1) - reduce(lambda x,y:x+y, m1))
 
66
            self.failUnless(eq(xm, xf))
 
67
            self.failUnless(eq(filled(xm, 1.e20), xf))
 
68
            self.failUnless(eq(x, xm))
 
69
            self.setUp()
 
70
 
 
71
    def check_testArithmetic (self):
 
72
        "Test of basic arithmetic."
 
73
        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
 
74
        a2d = array([[1,2],[0,4]])
 
75
        a2dm = masked_array(a2d, [[0,0],[1,0]])
 
76
        self.failUnless(eq (a2d * a2d, a2d * a2dm))
 
77
        self.failUnless(eq (a2d + a2d, a2d + a2dm))
 
78
        self.failUnless(eq (a2d - a2d, a2d - a2dm))
 
79
        for s in [(12,), (4,3), (2,6)]:
 
80
            x = x.reshape(s)
 
81
            y = y.reshape(s)
 
82
            xm = xm.reshape(s)
 
83
            ym = ym.reshape(s)
 
84
            xf = xf.reshape(s)
 
85
            self.failUnless(eq(-x, -xm))
 
86
            self.failUnless(eq(x + y, xm + ym))
 
87
            self.failUnless(eq(x - y, xm - ym))
 
88
            self.failUnless(eq(x * y, xm * ym))
 
89
            self.failUnless(eq(x / y, xm / ym))
 
90
            self.failUnless(eq(a10 + y, a10 + ym))
 
91
            self.failUnless(eq(a10 - y, a10 - ym))
 
92
            self.failUnless(eq(a10 * y, a10 * ym))
 
93
            self.failUnless(eq(a10 / y, a10 / ym))
 
94
            self.failUnless(eq(x + a10, xm + a10))
 
95
            self.failUnless(eq(x - a10, xm - a10))
 
96
            self.failUnless(eq(x * a10, xm * a10))
 
97
            self.failUnless(eq(x / a10, xm / a10))
 
98
            self.failUnless(eq(x**2, xm**2))
 
99
            self.failUnless(eq(abs(x)**2.5, abs(xm) **2.5))
 
100
            self.failUnless(eq(x**y, xm**ym))
 
101
            self.failUnless(eq(numpy.add(x,y), add(xm, ym)))
 
102
            self.failUnless(eq(numpy.subtract(x,y), subtract(xm, ym)))
 
103
            self.failUnless(eq(numpy.multiply(x,y), multiply(xm, ym)))
 
104
            self.failUnless(eq(numpy.divide(x,y), divide(xm, ym)))
 
105
 
 
106
 
 
107
    def check_testMixedArithmetic(self):
 
108
        na = numpy.array([1])
 
109
        ma = array([1])
 
110
        self.failUnless(isinstance(na + ma, MaskedArray))
 
111
        self.failUnless(isinstance(ma + na, MaskedArray))
 
112
 
 
113
    def check_testUfuncs1 (self):
 
114
        "Test various functions such as sin, cos."
 
115
        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
 
116
        self.failUnless (eq(numpy.cos(x), cos(xm)))
 
117
        self.failUnless (eq(numpy.cosh(x), cosh(xm)))
 
118
        self.failUnless (eq(numpy.sin(x), sin(xm)))
 
119
        self.failUnless (eq(numpy.sinh(x), sinh(xm)))
 
120
        self.failUnless (eq(numpy.tan(x), tan(xm)))
 
121
        self.failUnless (eq(numpy.tanh(x), tanh(xm)))
 
122
        self.failUnless (eq(numpy.sqrt(abs(x)), sqrt(xm)))
 
123
        self.failUnless (eq(numpy.log(abs(x)), log(xm)))
 
124
        self.failUnless (eq(numpy.log10(abs(x)), log10(xm)))
 
125
        self.failUnless (eq(numpy.exp(x), exp(xm)))
 
126
        self.failUnless (eq(numpy.arcsin(z), arcsin(zm)))
 
127
        self.failUnless (eq(numpy.arccos(z), arccos(zm)))
 
128
        self.failUnless (eq(numpy.arctan(z), arctan(zm)))
 
129
        self.failUnless (eq(numpy.arctan2(x, y), arctan2(xm, ym)))
 
130
        self.failUnless (eq(numpy.absolute(x), absolute(xm)))
 
131
        self.failUnless (eq(numpy.equal(x,y), equal(xm, ym)))
 
132
        self.failUnless (eq(numpy.not_equal(x,y), not_equal(xm, ym)))
 
133
        self.failUnless (eq(numpy.less(x,y), less(xm, ym)))
 
134
        self.failUnless (eq(numpy.greater(x,y), greater(xm, ym)))
 
135
        self.failUnless (eq(numpy.less_equal(x,y), less_equal(xm, ym)))
 
136
        self.failUnless (eq(numpy.greater_equal(x,y), greater_equal(xm, ym)))
 
137
        self.failUnless (eq(numpy.conjugate(x), conjugate(xm)))
 
138
        self.failUnless (eq(numpy.concatenate((x,y)), concatenate((xm,ym))))
 
139
        self.failUnless (eq(numpy.concatenate((x,y)), concatenate((x,y))))
 
140
        self.failUnless (eq(numpy.concatenate((x,y)), concatenate((xm,y))))
 
141
        self.failUnless (eq(numpy.concatenate((x,y,x)), concatenate((x,ym,x))))
 
142
 
 
143
    def check_xtestCount (self):
 
144
        "Test count"
 
145
        ott = array([0.,1.,2.,3.], mask=[1,0,0,0])
 
146
        self.failUnless( isinstance(count(ott), types.IntType))
 
147
        self.assertEqual(3, count(ott))
 
148
        self.assertEqual(1, count(1))
 
149
        self.failUnless (eq(0, array(1,mask=[1])))
 
150
        ott=ott.reshape((2,2))
 
151
        assert isMaskedArray(count(ott,0))
 
152
        assert isinstance(count(ott), types.IntType)
 
153
        self.failUnless (eq(3, count(ott)))
 
154
        assert getmask(count(ott,0)) is nomask
 
155
        self.failUnless (eq([1,2],count(ott,0)))
 
156
 
 
157
    def check_testMinMax (self):
 
158
        "Test minimum and maximum."
 
159
        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
 
160
        xr = numpy.ravel(x) #max doesn't work if shaped
 
161
        xmr = ravel(xm)
 
162
        self.failUnless (eq(max(xr), maximum(xmr))) #true because of careful selection of data
 
163
        self.failUnless (eq(min(xr), minimum(xmr))) #true because of careful selection of data
 
164
 
 
165
    def check_testAddSumProd (self):
 
166
        "Test add, sum, product."
 
167
        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
 
168
        self.failUnless (eq(numpy.add.reduce(x), add.reduce(x)))
 
169
        self.failUnless (eq(numpy.add.accumulate(x), add.accumulate(x)))
 
170
        self.failUnless (eq(4, sum(array(4))))
 
171
        self.failUnless (eq(4, sum(array(4), axis=0)))
 
172
        self.failUnless (eq(numpy.sum(x), sum(x)))
 
173
        self.failUnless (eq(numpy.sum(filled(xm,0)), sum(xm)))
 
174
        self.failUnless (eq(numpy.sum(x,0), sum(x,0)))
 
175
        self.failUnless (eq(numpy.product(x), product(x)))
 
176
        self.failUnless (eq(numpy.product(x,0), product(x,0)))
 
177
        self.failUnless (eq(numpy.product(filled(xm,1)), product(xm)))
 
178
        if len(s) > 1:
 
179
            self.failUnless (eq(numpy.concatenate((x,y),1), concatenate((xm,ym),1)))
 
180
            self.failUnless (eq(numpy.add.reduce(x,1), add.reduce(x,1)))
 
181
            self.failUnless (eq(numpy.sum(x,1), sum(x,1)))
 
182
            self.failUnless (eq(numpy.product(x,1), product(x,1)))
 
183
 
 
184
 
 
185
    def check_testCI(self):
 
186
        "Test of conversions and indexing"
 
187
        x1 = numpy.array([1,2,4,3])
 
188
        x2 = array(x1, mask = [1,0,0,0])
 
189
        x3 = array(x1, mask = [0,1,0,1])
 
190
        x4 = array(x1)
 
191
    # test conversion to strings
 
192
        junk, garbage = str(x2), repr(x2)
 
193
        assert eq(numpy.sort(x1),sort(x2, fill_value=0))
 
194
    # tests of indexing
 
195
        assert type(x2[1]) is type(x1[1])
 
196
        assert x1[1] == x2[1]
 
197
        assert x2[0] is masked
 
198
        assert eq(x1[2],x2[2])
 
199
        assert eq(x1[2:5],x2[2:5])
 
200
        assert eq(x1[:],x2[:])
 
201
        assert eq(x1[1:], x3[1:])
 
202
        x1[2]=9
 
203
        x2[2]=9
 
204
        assert eq(x1,x2)
 
205
        x1[1:3] = 99
 
206
        x2[1:3] = 99
 
207
        assert eq(x1,x2)
 
208
        x2[1] = masked
 
209
        assert eq(x1,x2)
 
210
        x2[1:3]=masked
 
211
        assert eq(x1,x2)
 
212
        x2[:] = x1
 
213
        x2[1] = masked
 
214
        assert allequal(getmask(x2),array([0,1,0,0]))
 
215
        x3[:] = masked_array([1,2,3,4],[0,1,1,0])
 
216
        assert allequal(getmask(x3), array([0,1,1,0]))
 
217
        x4[:] = masked_array([1,2,3,4],[0,1,1,0])
 
218
        assert allequal(getmask(x4), array([0,1,1,0]))
 
219
        assert allequal(x4, array([1,2,3,4]))
 
220
        x1 = numpy.arange(5)*1.0
 
221
        x2 = masked_values(x1, 3.0)
 
222
        assert eq(x1,x2)
 
223
        assert allequal(array([0,0,0,1,0],MaskType), x2.mask)
 
224
        assert eq(3.0, x2.fill_value())
 
225
        x1 = array([1,'hello',2,3],object)
 
226
        x2 = numpy.array([1,'hello',2,3],object)
 
227
        s1 = x1[1]
 
228
        s2 = x2[1]
 
229
        self.assertEqual(type(s2), str)
 
230
        self.assertEqual(type(s1), str)
 
231
        self.assertEqual(s1, s2)
 
232
        assert x1[1:1].shape == (0,)
 
233
 
 
234
    def check_testCopySize(self):
 
235
        "Tests of some subtle points of copying and sizing."
 
236
        n = [0,0,1,0,0]
 
237
        m = make_mask(n)
 
238
        m2 = make_mask(m)
 
239
        self.failUnless(m is m2)
 
240
        m3 = make_mask(m, copy=1)
 
241
        self.failUnless(m is not m3)
 
242
 
 
243
        x1 = numpy.arange(5)
 
244
        y1 = array(x1, mask=m)
 
245
        self.failUnless( y1.raw_data() is not x1)
 
246
        self.failUnless( allequal(x1,y1.raw_data()))
 
247
        self.failUnless( y1.mask is m)
 
248
 
 
249
        y1a = array(y1, copy=0)
 
250
        self.failUnless( y1a.raw_data() is y1.raw_data())
 
251
        self.failUnless( y1a.mask is y1.mask)
 
252
 
 
253
        y2 = array(x1, mask=m, copy=0)
 
254
        self.failUnless( y2.raw_data() is x1)
 
255
        self.failUnless( y2.mask is m)
 
256
        self.failUnless( y2[2] is masked)
 
257
        y2[2]=9
 
258
        self.failUnless( y2[2] is not masked)
 
259
        self.failUnless( y2.mask is not m)
 
260
        self.failUnless( allequal(y2.mask, 0))
 
261
 
 
262
        y3 = array(x1*1.0, mask=m)
 
263
        self.failUnless(filled(y3).dtype is (x1*1.0).dtype)
 
264
 
 
265
        x4 = arange(4)
 
266
        x4[2] = masked
 
267
        y4 = resize(x4, (8,))
 
268
        self.failUnless( eq(concatenate([x4,x4]), y4))
 
269
        self.failUnless( eq(getmask(y4),[0,0,1,0,0,0,1,0]))
 
270
        y5 = repeat(x4, (2,2,2,2))
 
271
        self.failUnless( eq(y5, [0,0,1,1,2,2,3,3]))
 
272
        y6 = repeat(x4, 2)
 
273
        self.failUnless( eq(y5, y6))
 
274
 
 
275
    def check_testPut(self):
 
276
        "Test of put"
 
277
        d = arange(5)
 
278
        n = [0,0,0,1,1]
 
279
        m = make_mask(n)
 
280
        x = array(d, mask = m)
 
281
        self.failUnless( x[3] is masked)
 
282
        self.failUnless( x[4] is masked)
 
283
        x[[1,4]] = [10,40]
 
284
        self.failUnless( x.mask is not m)
 
285
        self.failUnless( x[3] is masked)
 
286
        self.failUnless( x[4] is not masked)
 
287
        self.failUnless( eq(x, [0,10,2,-1,40]))
 
288
 
 
289
        x = array(d, mask = m)
 
290
        x.put([-1,100,200])
 
291
        self.failUnless( eq(x, [-1,100,200,0,0]))
 
292
        self.failUnless( x[3] is masked)
 
293
        self.failUnless( x[4] is masked)
 
294
 
 
295
        x = array(d, mask = m)
 
296
        x.putmask([30,40])
 
297
        self.failUnless( eq(x, [0,1,2,30,40]))
 
298
        self.failUnless( x.mask is nomask)
 
299
 
 
300
        x = array(d, mask = m)
 
301
        y = x.compressed()
 
302
        z = array(x, mask = m)
 
303
        z.put(y)
 
304
        assert eq (x, z)
 
305
 
 
306
    def check_testMaPut(self):
 
307
        (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d
 
308
        m = [1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1]
 
309
        i = numpy.nonzero(m)
 
310
        putmask(xm, m, z)
 
311
        assert take(xm, i) == z
 
312
        put(ym, i, zm)
 
313
        assert take(ym, i) == zm
 
314
 
 
315
    def check_testOddFeatures(self):
 
316
        "Test of other odd features"
 
317
        x = arange(20); x=x.reshape(4,5)
 
318
        x.flat[5] = 12
 
319
        assert x[1,0] == 12
 
320
        z = x + 10j * x
 
321
        assert eq(z.real, x)
 
322
        assert eq(z.imag, 10*x)
 
323
        assert eq((z*conjugate(z)).real, 101*x*x)
 
324
        z.imag[...] = 0.0
 
325
 
 
326
        x = arange(10)
 
327
        x[3] = masked
 
328
        assert str(x[3]) == str(masked)
 
329
        c = x >= 8
 
330
        assert count(where(c,masked,masked)) == 0
 
331
        assert shape(where(c,masked,masked)) == c.shape
 
332
        z = where(c , x, masked)
 
333
        assert z.dtype is x.dtype
 
334
        assert z[3] is masked
 
335
        assert z[4] is masked
 
336
        assert z[7] is masked
 
337
        assert z[8] is not masked
 
338
        assert z[9] is not masked
 
339
        assert eq(x,z)
 
340
        z = where(c , masked, x)
 
341
        assert z.dtype is x.dtype
 
342
        assert z[3] is masked
 
343
        assert z[4] is not masked
 
344
        assert z[7] is not masked
 
345
        assert z[8] is masked
 
346
        assert z[9] is masked
 
347
        z = masked_where(c, x)
 
348
        assert z.dtype is x.dtype
 
349
        assert z[3] is masked
 
350
        assert z[4] is not masked
 
351
        assert z[7] is not masked
 
352
        assert z[8] is masked
 
353
        assert z[9] is masked
 
354
        assert eq(x,z)
 
355
        x = array([1.,2.,3.,4.,5.])
 
356
        c = array([1,1,1,0,0])
 
357
        x[2] = masked
 
358
        z = where(c, x, -x)
 
359
        assert eq(z, [1.,2.,0., -4., -5])
 
360
        c[0] = masked
 
361
        z = where(c, x, -x)
 
362
        assert eq(z, [1.,2.,0., -4., -5])
 
363
        assert z[0] is masked
 
364
        assert z[1] is not masked
 
365
        assert z[2] is masked
 
366
        assert eq(masked_where(greater(x, 2), x), masked_greater(x,2))
 
367
        assert eq(masked_where(greater_equal(x, 2), x), masked_greater_equal(x,2))
 
368
        assert eq(masked_where(less(x, 2), x), masked_less(x,2))
 
369
        assert eq(masked_where(less_equal(x, 2), x), masked_less_equal(x,2))
 
370
        assert eq(masked_where(not_equal(x, 2), x), masked_not_equal(x,2))
 
371
        assert eq(masked_where(equal(x, 2), x), masked_equal(x,2))
 
372
        assert eq(masked_where(not_equal(x,2), x), masked_not_equal(x,2))
 
373
        assert eq(masked_inside(range(5), 1, 3), [0, 199, 199, 199, 4])
 
374
        assert eq(masked_outside(range(5), 1, 3),[199,1,2,3,199])
 
375
        assert eq(masked_inside(array(range(5), mask=[1,0,0,0,0]), 1, 3).mask, [1,1,1,1,0])
 
376
        assert eq(masked_outside(array(range(5), mask=[0,1,0,0,0]), 1, 3).mask, [1,1,0,0,1])
 
377
        assert eq(masked_equal(array(range(5), mask=[1,0,0,0,0]), 2).mask, [1,0,1,0,0])
 
378
        assert eq(masked_not_equal(array([2,2,1,2,1], mask=[1,0,0,0,0]), 2).mask, [1,0,1,0,1])
 
379
        assert eq(masked_where([1,1,0,0,0], [1,2,3,4,5]), [99,99,3,4,5])
 
380
        atest = ones((10,10,10), dtype=float32)
 
381
        btest = zeros(atest.shape, MaskType)
 
382
        ctest = masked_where(btest,atest)
 
383
        assert eq(atest,ctest)
 
384
        z = choose(c, (-x, x))
 
385
        assert eq(z, [1.,2.,0., -4., -5])
 
386
        assert z[0] is masked
 
387
        assert z[1] is not masked
 
388
        assert z[2] is masked
 
389
        x = arange(6)
 
390
        x[5] = masked
 
391
        y = arange(6)*10
 
392
        y[2]= masked
 
393
        c = array([1,1,1,0,0,0], mask=[1,0,0,0,0,0])
 
394
        cm = c.filled(1)
 
395
        z = where(c,x,y)
 
396
        zm = where(cm,x,y)
 
397
        assert eq(z, zm)
 
398
        assert getmask(zm) is nomask
 
399
        assert eq(zm, [0,1,2,30,40,50])
 
400
        z = where(c, masked, 1)
 
401
        assert eq(z, [99,99,99,1,1,1])
 
402
        z = where(c, 1, masked)
 
403
        assert eq(z, [99, 1, 1, 99, 99, 99])
 
404
 
 
405
    def check_testMinMax(self):
 
406
        "Test of minumum, maximum."
 
407
        assert eq(minimum([1,2,3],[4,0,9]), [1,0,3])
 
408
        assert eq(maximum([1,2,3],[4,0,9]), [4,2,9])
 
409
        x = arange(5)
 
410
        y = arange(5) - 2
 
411
        x[3] = masked
 
412
        y[0] = masked
 
413
        assert eq(minimum(x,y), where(less(x,y), x, y))
 
414
        assert eq(maximum(x,y), where(greater(x,y), x, y))
 
415
        assert minimum(x) == 0
 
416
        assert maximum(x) == 4
 
417
 
 
418
    def check_testTakeTransposeInnerOuter(self):
 
419
        "Test of take, transpose, inner, outer products"
 
420
        x = arange(24)
 
421
        y = numpy.arange(24)
 
422
        x[5:6] = masked
 
423
        x=x.reshape(2,3,4)
 
424
        y=y.reshape(2,3,4)
 
425
        assert eq(numpy.transpose(y,(2,0,1)), transpose(x,(2,0,1)))
 
426
        assert eq(numpy.take(y, (2,0,1), 1), take(x, (2,0,1), 1))
 
427
        assert eq(numpy.innerproduct(filled(x,0),filled(y,0)),
 
428
                                innerproduct(x, y))
 
429
        assert eq(numpy.outerproduct(filled(x,0),filled(y,0)),
 
430
                                outerproduct(x, y))
 
431
        y = array(['abc', 1, 'def', 2, 3], object)
 
432
        y[2] = masked
 
433
        t = take(y,[0,3,4])
 
434
        assert t[0] == 'abc'
 
435
        assert t[1] == 2
 
436
        assert t[2] == 3
 
437
 
 
438
    def check_testInplace(self):
 
439
        """Test of inplace operations and rich comparisons"""
 
440
        y = arange(10)
 
441
 
 
442
        x = arange(10)
 
443
        xm = arange(10)
 
444
        xm[2] = masked
 
445
        x += 1
 
446
        assert eq(x, y+1)
 
447
        xm += 1
 
448
        assert eq(x, y+1)
 
449
 
 
450
        x = arange(10)
 
451
        xm = arange(10)
 
452
        xm[2] = masked
 
453
        x -= 1
 
454
        assert eq(x, y-1)
 
455
        xm -= 1
 
456
        assert eq(xm, y-1)
 
457
 
 
458
        x = arange(10)*1.0
 
459
        xm = arange(10)*1.0
 
460
        xm[2] = masked
 
461
        x *= 2.0
 
462
        assert eq(x, y*2)
 
463
        xm *= 2.0
 
464
        assert eq(xm, y*2)
 
465
 
 
466
        x = arange(10)*2
 
467
        xm = arange(10)
 
468
        xm[2] = masked
 
469
        x /= 2
 
470
        assert eq(x, y)
 
471
        xm /= 2
 
472
        assert eq(x, y)
 
473
 
 
474
        x = arange(10)*1.0
 
475
        xm = arange(10)*1.0
 
476
        xm[2] = masked
 
477
        x /= 2.0
 
478
        assert eq(x, y/2.0)
 
479
        xm /= arange(10)
 
480
        assert eq(xm, ones((10,)))
 
481
 
 
482
        x = arange(10).astype(float32)
 
483
        xm = arange(10)
 
484
        xm[2] = masked
 
485
        id1 = id(x.raw_data())
 
486
        x += 1.
 
487
        assert id1 == id(x.raw_data())
 
488
        assert eq(x, y+1.)
 
489
 
 
490
    def check_testPickle(self):
 
491
        "Test of pickling"
 
492
        import pickle
 
493
        x = arange(12)
 
494
        x[4:10:2] = masked
 
495
        x = x.reshape(4,3)
 
496
        s = pickle.dumps(x)
 
497
        y = pickle.loads(s)
 
498
        assert eq(x,y)
 
499
 
 
500
    def check_testMasked(self):
 
501
        "Test of masked element"
 
502
        xx=arange(6)
 
503
        xx[1] = masked
 
504
        self.failUnless(str(masked) ==  '--')
 
505
        self.failUnless(xx[1] is masked)
 
506
        self.failUnlessEqual(filled(xx[1], 0), 0)
 
507
        # don't know why these should raise an exception...
 
508
        #self.failUnlessRaises(Exception, lambda x,y: x+y, masked, masked)
 
509
        #self.failUnlessRaises(Exception, lambda x,y: x+y, masked, 2)
 
510
        #self.failUnlessRaises(Exception, lambda x,y: x+y, masked, xx)
 
511
        #self.failUnlessRaises(Exception, lambda x,y: x+y, xx, masked)
 
512
 
 
513
    def check_testAverage1(self):
 
514
        "Test of average."
 
515
        ott = array([0.,1.,2.,3.], mask=[1,0,0,0])
 
516
        self.failUnless(eq(2.0, average(ott)))
 
517
        self.failUnless(eq(2.0, average(ott, weights=[1., 1., 2., 1.])))
 
518
        result, wts = average(ott, weights=[1.,1.,2.,1.], returned=1)
 
519
        self.failUnless(eq(2.0, result))
 
520
        self.failUnless(wts == 4.0)
 
521
        ott[:] = masked
 
522
        self.failUnless(average(ott) is masked)
 
523
        ott = array([0.,1.,2.,3.], mask=[1,0,0,0])
 
524
        ott=ott.reshape(2,2)
 
525
        ott[:,1] = masked
 
526
        self.failUnless(eq(average(ott), [2.0, 0.0]))
 
527
        self.failUnless(average(ott,axis=1)[0] is masked)
 
528
        self.failUnless(eq([2.,0.], average(ott)))
 
529
        result, wts = average(ott, returned=1)
 
530
        self.failUnless(eq(wts, [1., 0.]))
 
531
 
 
532
    def check_testAverage2(self):
 
533
        "More tests of average."
 
534
        w1 = [0,1,1,1,1,0]
 
535
        w2 = [[0,1,1,1,1,0],[1,0,0,0,0,1]]
 
536
        x=arange(6)
 
537
        self.failUnless(allclose(average(x), 2.5))
 
538
        self.failUnless(allclose(average(x, weights=w1), 2.5))
 
539
        y=array([arange(6), 2.0*arange(6)])
 
540
        self.failUnless(allclose(average(y, None), numpy.add.reduce(numpy.arange(6))*3./12.))
 
541
        self.failUnless(allclose(average(y, axis=0), numpy.arange(6) * 3./2.))
 
542
        self.failUnless(allclose(average(y, axis=1), [average(x), average(x) * 2.0]))
 
543
        self.failUnless(allclose(average(y, None, weights=w2), 20./6.))
 
544
        self.failUnless(allclose(average(y, axis=0, weights=w2), [0.,1.,2.,3.,4.,10.]))
 
545
        self.failUnless(allclose(average(y, axis=1), [average(x), average(x) * 2.0]))
 
546
        m1 = zeros(6)
 
547
        m2 = [0,0,1,1,0,0]
 
548
        m3 = [[0,0,1,1,0,0],[0,1,1,1,1,0]]
 
549
        m4 = ones(6)
 
550
        m5 = [0, 1, 1, 1, 1, 1]
 
551
        self.failUnless(allclose(average(masked_array(x, m1)), 2.5))
 
552
        self.failUnless(allclose(average(masked_array(x, m2)), 2.5))
 
553
        self.failUnless(average(masked_array(x, m4)) is masked)
 
554
        self.assertEqual(average(masked_array(x, m5)), 0.0)
 
555
        self.assertEqual(count(average(masked_array(x, m4))), 0)
 
556
        z = masked_array(y, m3)
 
557
        self.failUnless(allclose(average(z, None), 20./6.))
 
558
        self.failUnless(allclose(average(z, axis=0), [0.,1.,99.,99.,4.0, 7.5]))
 
559
        self.failUnless(allclose(average(z, axis=1), [2.5, 5.0]))
 
560
        self.failUnless(allclose( average(z,weights=w2), [0.,1., 99., 99., 4.0, 10.0]))
 
561
 
 
562
        a = arange(6)
 
563
        b = arange(6) * 3
 
564
        r1, w1 = average([[a,b],[b,a]], axis=1, returned=1)
 
565
        self.assertEqual(shape(r1) , shape(w1))
 
566
        self.assertEqual(r1.shape , w1.shape)
 
567
        r2, w2 = average(ones((2,2,3)), axis=0, weights=[3,1], returned=1)
 
568
        self.assertEqual(shape(w2) , shape(r2))
 
569
        r2, w2 = average(ones((2,2,3)), returned=1)
 
570
        self.assertEqual(shape(w2) , shape(r2))
 
571
        r2, w2 = average(ones((2,2,3)), weights=ones((2,2,3)), returned=1)
 
572
        self.failUnless(shape(w2) == shape(r2))
 
573
        a2d = array([[1,2],[0,4]], float)
 
574
        a2dm = masked_array(a2d, [[0,0],[1,0]])
 
575
        a2da = average(a2d)
 
576
        self.failUnless(eq (a2da, [0.5, 3.0]))
 
577
        a2dma = average(a2dm)
 
578
        self.failUnless(eq( a2dma, [1.0, 3.0]))
 
579
        a2dma = average(a2dm, axis=None)
 
580
        self.failUnless(eq(a2dma, 7./3.))
 
581
        a2dma = average(a2dm, axis=1)
 
582
        self.failUnless(eq(a2dma, [1.5, 4.0]))
 
583
 
 
584
    def check_testToPython(self):
 
585
        self.assertEqual(1, int(array(1)))
 
586
        self.assertEqual(1.0, float(array(1)))
 
587
        self.assertEqual(1, int(array([[[1]]])))
 
588
        self.assertEqual(1.0, float(array([[1]])))
 
589
        self.failUnlessRaises(ValueError, float, array([1,1]))
 
590
        self.failUnlessRaises(MAError, float, array([1],mask=[1]))
 
591
        self.failUnless(bool(array([0,1])))
 
592
        self.failUnless(bool(array([0,0],mask=[0,1])))
 
593
        self.failIf(bool(array([0,0])))
 
594
        self.failIf(bool(array([0,0],mask=[0,0])))
 
595
 
 
596
    def check_testScalarArithmetic(self):
 
597
        xm = array(0, mask=1)
 
598
        self.failUnless((1/array(0)).mask)
 
599
        self.failUnless((1 + xm).mask)
 
600
        self.failUnless((-xm).mask)
 
601
        self.failUnless((-xm).mask)
 
602
        self.failUnless(maximum(xm, xm).mask)
 
603
        self.failUnless(minimum(xm, xm).mask)
 
604
        self.failUnless(xm.filled().dtype is xm.data.dtype)
 
605
        x = array(0, mask=0)
 
606
        self.failUnless(x.filled() is x.data)
 
607
        self.failUnlessEqual(str(xm), str(masked_print_option))
 
608
 
 
609
    def check_testArrayMethods(self):
 
610
        a = array([1,3,2])
 
611
        b = array([1,3,2], mask=[1,0,1])
 
612
        self.failUnless(eq(a.any(), a.data.any()))
 
613
        self.failUnless(eq(a.all(), a.data.all()))
 
614
        self.failUnless(eq(a.argmax(), a.data.argmax()))
 
615
        self.failUnless(eq(a.argmin(), a.data.argmin()))
 
616
        self.failUnless(eq(a.choose(0,1,2,3,4), a.data.choose(0,1,2,3,4)))
 
617
        self.failUnless(eq(a.compress([1,0,1]), a.data.compress([1,0,1])))
 
618
        self.failUnless(eq(a.conj(), a.data.conj()))
 
619
        self.failUnless(eq(a.conjugate(), a.data.conjugate()))
 
620
        m = array([[1,2],[3,4]])
 
621
        self.failUnless(eq(m.diagonal(), m.data.diagonal()))
 
622
        self.failUnless(eq(a.sum(), a.data.sum()))
 
623
        self.failUnless(eq(a.take([1,2]), a.data.take([1,2])))
 
624
        self.failUnless(eq(m.transpose(), m.data.transpose()))
 
625
 
 
626
    def check_testArrayAttributes(self):
 
627
        a = array([1,3,2])
 
628
        b = array([1,3,2], mask=[1,0,1])
 
629
        self.failUnlessEqual(a.ndim, 1)
 
630
 
 
631
    def check_testAPI(self):
 
632
        self.failIf([m for m in dir(numpy.ndarray)
 
633
                     if m not in dir(array) and not m.startswith('_')])
 
634
 
 
635
    def check_testSingleElementSubscript(self):
 
636
        a = array([1,3,2])
 
637
        b = array([1,3,2], mask=[1,0,1])
 
638
        self.failUnlessEqual(a[0].shape, ())
 
639
        self.failUnlessEqual(b[0].shape, ())
 
640
        self.failUnlessEqual(b[1].shape, ())
 
641
 
 
642
class test_ufuncs(ScipyTestCase):
 
643
    def setUp(self):
 
644
        self.d = (array([1.0, 0, -1, pi/2]*2, mask=[0,1]+[0]*6),
 
645
                  array([1.0, 0, -1, pi/2]*2, mask=[1,0]+[0]*6),)
 
646
 
 
647
 
 
648
    def check_testUfuncRegression(self):
 
649
        for f in ['sqrt', 'log', 'log10', 'exp', 'conjugate',
 
650
                  'sin', 'cos', 'tan',
 
651
                  'arcsin', 'arccos', 'arctan',
 
652
                  'sinh', 'cosh', 'tanh',
 
653
                  'arcsinh',
 
654
                  'arccosh',
 
655
                  'arctanh',
 
656
                  'absolute', 'fabs', 'negative',
 
657
                  # 'nonzero', 'around',
 
658
                  'floor', 'ceil',
 
659
                  # 'sometrue', 'alltrue',
 
660
                  'logical_not',
 
661
                  'add', 'subtract', 'multiply',
 
662
                  'divide', 'true_divide', 'floor_divide',
 
663
                  'remainder', 'fmod', 'hypot', 'arctan2',
 
664
                  'equal', 'not_equal', 'less_equal', 'greater_equal',
 
665
                  'less', 'greater',
 
666
                  'logical_and', 'logical_or', 'logical_xor',
 
667
                  ]:
 
668
            try:
 
669
                uf = getattr(umath, f)
 
670
            except AttributeError:
 
671
                uf = getattr(oldnumeric, f)
 
672
            mf = getattr(numpy.ma, f)
 
673
            args = self.d[:uf.nin]
 
674
            ur = uf(*args)
 
675
            mr = mf(*args)
 
676
            self.failUnless(eq(ur.filled(0), mr.filled(0), f))
 
677
            self.failUnless(eqmask(ur.mask, mr.mask))
 
678
 
 
679
    def test_reduce(self):
 
680
        a = self.d[0]
 
681
        self.failIf(alltrue(a))
 
682
        self.failUnless(sometrue(a))
 
683
        self.failUnlessEqual(sum(a[:3]), 0)
 
684
        self.failUnlessEqual(product(a), 0)
 
685
 
 
686
    def test_minmax(self):
 
687
        a = arange(1,13).reshape(3,4)
 
688
        amask = masked_where(a < 5,a)
 
689
        self.failUnlessEqual(amask.max(), a.max())
 
690
        self.failUnlessEqual(amask.min(), 5)
 
691
        self.failUnless((amask.max(0) == a.max(0)).all())
 
692
        self.failUnless((amask.min(0) == [5,6,7,8]).all())
 
693
        self.failUnless(amask.max(1)[0].mask)
 
694
        self.failUnless(amask.min(1)[0].mask)
 
695
 
 
696
    def test_nonzero(self):
 
697
        for t in "?bhilqpBHILQPfdgFDGO":
 
698
            x = array([1,0,2,0], mask=[0,0,1,1])
 
699
            self.failUnless(eq(nonzero(x), [0]))
 
700
 
 
701
 
 
702
class test_array_methods(ScipyTestCase):
 
703
        
 
704
    def setUp(self):
 
705
        x = numpy.array([ 8.375,  7.545,  8.828,  8.5  ,  1.757,  5.928,  
 
706
                          8.43 ,  7.78 ,  9.865,  5.878,  8.979,  4.732,  
 
707
                          3.012,  6.022,  5.095,  3.116,  5.238,  3.957,  
 
708
                          6.04 ,  9.63 ,  7.712,  3.382,  4.489,  6.479,
 
709
                          7.189,  9.645,  5.395,  4.961,  9.894,  2.893,  
 
710
                          7.357,  9.828,  6.272,  3.758,  6.693,  0.993])
 
711
        X = x.reshape(6,6)
 
712
        XX = x.reshape(3,2,2,3)
 
713
    
 
714
        m = numpy.array([0, 1, 0, 1, 0, 0, 
 
715
                         1, 0, 1, 1, 0, 1, 
 
716
                         0, 0, 0, 1, 0, 1, 
 
717
                         0, 0, 0, 1, 1, 1, 
 
718
                         1, 0, 0, 1, 0, 0, 
 
719
                         0, 0, 1, 0, 1, 0])
 
720
        mx = array(data=x,mask=m)
 
721
        mX = array(data=X,mask=m.reshape(X.shape))
 
722
        mXX = array(data=XX,mask=m.reshape(XX.shape))
 
723
    
 
724
        m2 = numpy.array([1, 1, 0, 1, 0, 0, 
 
725
                          1, 1, 1, 1, 0, 1, 
 
726
                          0, 0, 1, 1, 0, 1, 
 
727
                          0, 0, 0, 1, 1, 1, 
 
728
                          1, 0, 0, 1, 1, 0, 
 
729
                          0, 0, 1, 0, 1, 1])
 
730
        m2x = array(data=x,mask=m2)
 
731
        m2X = array(data=X,mask=m2.reshape(X.shape))
 
732
        m2XX = array(data=XX,mask=m2.reshape(XX.shape))
 
733
        self.d =  (x,X,XX,m,mx,mX,mXX)
 
734
 
 
735
    #------------------------------------------------------
 
736
    def test_trace(self):
 
737
        (x,X,XX,m,mx,mX,mXX,) = self.d
 
738
        mXdiag = mX.diagonal()
 
739
        self.assertEqual(mX.trace(), mX.diagonal().compressed().sum())
 
740
        self.failUnless(eq(mX.trace(),
 
741
                           X.trace() - sum(mXdiag.mask*X.diagonal())))
 
742
 
 
743
    def test_clip(self):
 
744
        (x,X,XX,m,mx,mX,mXX,) = self.d
 
745
        clipped = mx.clip(2,8)
 
746
        self.failUnless(eq(clipped.mask,mx.mask))
 
747
        self.failUnless(eq(clipped.data,x.clip(2,8)))
 
748
        self.failUnless(eq(clipped.data,mx.data.clip(2,8)))
 
749
 
 
750
    def test_ptp(self):
 
751
        (x,X,XX,m,mx,mX,mXX,) = self.d
 
752
        (n,m) = X.shape
 
753
        self.assertEqual(mx.ptp(),mx.compressed().ptp())
 
754
        rows = numpy.zeros(n,numpy.float_)
 
755
        cols = numpy.zeros(m,numpy.float_)
 
756
        for k in range(m):
 
757
            cols[k] = mX[:,k].compressed().ptp()
 
758
        for k in range(n):
 
759
            rows[k] = mX[k].compressed().ptp()
 
760
        self.failUnless(eq(mX.ptp(0),cols))
 
761
        self.failUnless(eq(mX.ptp(1),rows))
 
762
 
 
763
    def test_swapaxes(self):
 
764
        (x,X,XX,m,mx,mX,mXX,) = self.d
 
765
        mXswapped = mX.swapaxes(0,1)
 
766
        self.failUnless(eq(mXswapped[-1],mX[:,-1]))
 
767
        mXXswapped = mXX.swapaxes(0,2)
 
768
        self.assertEqual(mXXswapped.shape,(2,2,3,3))
 
769
 
 
770
 
 
771
    def test_cumprod(self):
 
772
        (x,X,XX,m,mx,mX,mXX,) = self.d
 
773
        mXcp = mX.cumprod(0)
 
774
        self.failUnless(eq(mXcp.data,mX.filled(1).cumprod(0)))
 
775
        mXcp = mX.cumprod(1)
 
776
        self.failUnless(eq(mXcp.data,mX.filled(1).cumprod(1)))
 
777
                           
 
778
    def test_cumsum(self):
 
779
        (x,X,XX,m,mx,mX,mXX,) = self.d
 
780
        mXcp = mX.cumsum(0)
 
781
        self.failUnless(eq(mXcp.data,mX.filled(0).cumsum(0)))
 
782
        mXcp = mX.cumsum(1)
 
783
        self.failUnless(eq(mXcp.data,mX.filled(0).cumsum(1)))
 
784
                           
 
785
    def test_varstd(self):
 
786
        (x,X,XX,m,mx,mX,mXX,) = self.d
 
787
        self.failUnless(eq(mX.var(axis=None),mX.compressed().var()))
 
788
        self.failUnless(eq(mX.std(axis=None),mX.compressed().std()))
 
789
        self.failUnless(eq(mXX.var(axis=3).shape,XX.var(axis=3).shape))
 
790
        self.failUnless(eq(mX.var().shape,X.var().shape))
 
791
        (mXvar0,mXvar1) = (mX.var(axis=0), mX.var(axis=1))
 
792
        for k in range(6):
 
793
            self.failUnless(eq(mXvar1[k],mX[k].compressed().var()))
 
794
            self.failUnless(eq(mXvar0[k],mX[:,k].compressed().var()))
 
795
            self.failUnless(eq(numpy.sqrt(mXvar0[k]),
 
796
                               mX[:,k].compressed().std()))
 
797
        
 
798
 
 
799
def eqmask(m1, m2):
 
800
    if m1 is nomask:
 
801
        return m2 is nomask
 
802
    if m2 is nomask:
 
803
        return m1 is nomask
 
804
    return (m1 == m2).all()
 
805
 
 
806
def timingTest():
 
807
    for f in [testf, testinplace]:
 
808
        for n in [1000,10000,50000]:
 
809
            t = testta(n, f)
 
810
            t1 = testtb(n, f)
 
811
            t2 = testtc(n, f)
 
812
            print f.test_name
 
813
            print """\
 
814
n = %7d
 
815
numpy time (ms) %6.1f
 
816
MA maskless ratio %6.1f
 
817
MA masked ratio %6.1f
 
818
""" % (n, t*1000.0, t1/t, t2/t)
 
819
 
 
820
def testta(n, f):
 
821
    x=numpy.arange(n) + 1.0
 
822
    tn0 = time.time()
 
823
    z = f(x)
 
824
    return time.time() - tn0
 
825
 
 
826
def testtb(n, f):
 
827
    x=arange(n) + 1.0
 
828
    tn0 = time.time()
 
829
    z = f(x)
 
830
    return time.time() - tn0
 
831
 
 
832
def testtc(n, f):
 
833
    x=arange(n) + 1.0
 
834
    x[0] = masked
 
835
    tn0 = time.time()
 
836
    z = f(x)
 
837
    return time.time() - tn0
 
838
 
 
839
def testf(x):
 
840
    for i in range(25):
 
841
        y = x **2 +  2.0 * x - 1.0
 
842
        w = x **2 +  1.0
 
843
        z = (y / w) ** 2
 
844
    return z
 
845
testf.test_name = 'Simple arithmetic'
 
846
 
 
847
def testinplace(x):
 
848
    for i in range(25):
 
849
        y = x**2
 
850
        y += 2.0*x
 
851
        y -= 1.0
 
852
        y /= x
 
853
    return y
 
854
testinplace.test_name = 'Inplace operations'
 
855
 
 
856
if __name__ == "__main__":
 
857
    ScipyTest('numpy.core.ma').run()
 
858
    #timingTest()