~vcs-imports/numpy/master : revision 8147

3

import sys

4

from functools import reduce

5

6

import numpy

6

import numpy as np

7

from numpy.ma import *

8

from numpy.core.numerictypes import float32

9

from numpy.ma.core import umath

10

from numpy.testing import *

11

12

13

pi = numpy.pi

13

pi = np.pi

14

def eq(v, w, msg=''):

15

result = allclose(v, w)

16

if not result:

22

23

class TestMa(TestCase):

24

def setUp (self):

25

x = numpy.array([1., 1., 1., -2., pi / 2.0, 4., 5., -10., 10., 1., 2., 3.])

26

y = numpy.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])

25

x = np.array([1., 1., 1., -2., pi / 2.0, 4., 5., -10., 10., 1., 2., 3.])

26

y = np.array([5., 0., 3., 2., -1., -4., 0., -10., 10., 1., 0., 3.])

27

a10 = 10.

28

m1 = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]

29

m2 = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0 , 0, 1]

30

xm = array(x, mask=m1)

31

ym = array(y, mask=m2)

32

z = numpy.array([-.5, 0., .5, .8])

32

z = np.array([-.5, 0., .5, .8])

33

zm = array(z, mask=[0, 1, 0, 0])

34

xf = numpy.where(m1, 1e+20, x)

34

xf = np.where(m1, 1e+20, x)

35

s = x.shape

36

xm.set_fill_value(1e+20)

37

self.d = (x, y, a10, m1, m2, xm, ym, z, zm, xf, s)

89

self.assertTrue(eq(x + y, xm + ym))

90

self.assertTrue(eq(x - y, xm - ym))

91

self.assertTrue(eq(x * y, xm * ym))

92

olderr = numpy.seterr(divide='ignore', invalid='ignore')

93

try:

92

with np.errstate(divide='ignore', invalid='ignore'):

94

93

self.assertTrue(eq(x / y, xm / ym))

95

finally:

96

numpy.seterr(**olderr)

97

94

self.assertTrue(eq(a10 + y, a10 + ym))

98

95

self.assertTrue(eq(a10 - y, a10 - ym))

99

96

self.assertTrue(eq(a10 * y, a10 * ym))

100

olderr = numpy.seterr(divide='ignore', invalid='ignore')

101

try:

97

with np.errstate(divide='ignore', invalid='ignore'):

102

98

self.assertTrue(eq(a10 / y, a10 / ym))

103

finally:

104

numpy.seterr(**olderr)

105

99

self.assertTrue(eq(x + a10, xm + a10))

106

100

self.assertTrue(eq(x - a10, xm - a10))

107

101

self.assertTrue(eq(x * a10, xm * a10))

109

103

self.assertTrue(eq(x ** 2, xm ** 2))

110

104

self.assertTrue(eq(abs(x) ** 2.5, abs(xm) ** 2.5))

111

105

self.assertTrue(eq(x ** y, xm ** ym))

112

self.assertTrue(eq(numpy.add(x, y), add(xm, ym)))

113

self.assertTrue(eq(numpy.subtract(x, y), subtract(xm, ym)))

114

self.assertTrue(eq(numpy.multiply(x, y), multiply(xm, ym)))

115

olderr = numpy.seterr(divide='ignore', invalid='ignore')

116

try:

117

self.assertTrue(eq(numpy.divide(x, y), divide(xm, ym)))

118

finally:

119

numpy.seterr(**olderr)

106

self.assertTrue(eq(np.add(x, y), add(xm, ym)))

107

self.assertTrue(eq(np.subtract(x, y), subtract(xm, ym)))

108

self.assertTrue(eq(np.multiply(x, y), multiply(xm, ym)))

109

with np.errstate(divide='ignore', invalid='ignore'):

110

self.assertTrue(eq(np.divide(x, y), divide(xm, ym)))

120

111

121

112

122

113

def test_testMixedArithmetic(self):

123

na = numpy.array([1])

114

na = np.array([1])

124

115

ma = array([1])

125

116

self.assertTrue(isinstance(na + ma, MaskedArray))

126

117

self.assertTrue(isinstance(ma + na, MaskedArray))

128

119

def test_testUfuncs1 (self):

129

120

"Test various functions such as sin, cos."

130

121

(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d

131

self.assertTrue (eq(numpy.cos(x), cos(xm)))

132

self.assertTrue (eq(numpy.cosh(x), cosh(xm)))

133

self.assertTrue (eq(numpy.sin(x), sin(xm)))

134

self.assertTrue (eq(numpy.sinh(x), sinh(xm)))

135

self.assertTrue (eq(numpy.tan(x), tan(xm)))

136

self.assertTrue (eq(numpy.tanh(x), tanh(xm)))

137

olderr = numpy.seterr(divide='ignore', invalid='ignore')

138

try:

139

self.assertTrue (eq(numpy.sqrt(abs(x)), sqrt(xm)))

140

self.assertTrue (eq(numpy.log(abs(x)), log(xm)))

141

self.assertTrue (eq(numpy.log10(abs(x)), log10(xm)))

142

finally:

143

numpy.seterr(**olderr)

144

self.assertTrue (eq(numpy.exp(x), exp(xm)))

145

self.assertTrue (eq(numpy.arcsin(z), arcsin(zm)))

146

self.assertTrue (eq(numpy.arccos(z), arccos(zm)))

147

self.assertTrue (eq(numpy.arctan(z), arctan(zm)))

148

self.assertTrue (eq(numpy.arctan2(x, y), arctan2(xm, ym)))

149

self.assertTrue (eq(numpy.absolute(x), absolute(xm)))

150

self.assertTrue (eq(numpy.equal(x, y), equal(xm, ym)))

151

self.assertTrue (eq(numpy.not_equal(x, y), not_equal(xm, ym)))

152

self.assertTrue (eq(numpy.less(x, y), less(xm, ym)))

153

self.assertTrue (eq(numpy.greater(x, y), greater(xm, ym)))

154

self.assertTrue (eq(numpy.less_equal(x, y), less_equal(xm, ym)))

155

self.assertTrue (eq(numpy.greater_equal(x, y), greater_equal(xm, ym)))

156

self.assertTrue (eq(numpy.conjugate(x), conjugate(xm)))

157

self.assertTrue (eq(numpy.concatenate((x, y)), concatenate((xm, ym))))

158

self.assertTrue (eq(numpy.concatenate((x, y)), concatenate((x, y))))

159

self.assertTrue (eq(numpy.concatenate((x, y)), concatenate((xm, y))))

160

self.assertTrue (eq(numpy.concatenate((x, y, x)), concatenate((x, ym, x))))

122

self.assertTrue (eq(np.cos(x), cos(xm)))

123

self.assertTrue (eq(np.cosh(x), cosh(xm)))

124

self.assertTrue (eq(np.sin(x), sin(xm)))

125

self.assertTrue (eq(np.sinh(x), sinh(xm)))

126

self.assertTrue (eq(np.tan(x), tan(xm)))

127

self.assertTrue (eq(np.tanh(x), tanh(xm)))

128

with np.errstate(divide='ignore', invalid='ignore'):

129

self.assertTrue (eq(np.sqrt(abs(x)), sqrt(xm)))

130

self.assertTrue (eq(np.log(abs(x)), log(xm)))

131

self.assertTrue (eq(np.log10(abs(x)), log10(xm)))

132

self.assertTrue (eq(np.exp(x), exp(xm)))

133

self.assertTrue (eq(np.arcsin(z), arcsin(zm)))

134

self.assertTrue (eq(np.arccos(z), arccos(zm)))

135

self.assertTrue (eq(np.arctan(z), arctan(zm)))

136

self.assertTrue (eq(np.arctan2(x, y), arctan2(xm, ym)))

137

self.assertTrue (eq(np.absolute(x), absolute(xm)))

138

self.assertTrue (eq(np.equal(x, y), equal(xm, ym)))

139

self.assertTrue (eq(np.not_equal(x, y), not_equal(xm, ym)))

140

self.assertTrue (eq(np.less(x, y), less(xm, ym)))

141

self.assertTrue (eq(np.greater(x, y), greater(xm, ym)))

142

self.assertTrue (eq(np.less_equal(x, y), less_equal(xm, ym)))

143

self.assertTrue (eq(np.greater_equal(x, y), greater_equal(xm, ym)))

144

self.assertTrue (eq(np.conjugate(x), conjugate(xm)))

145

self.assertTrue (eq(np.concatenate((x, y)), concatenate((xm, ym))))

146

self.assertTrue (eq(np.concatenate((x, y)), concatenate((x, y))))

147

self.assertTrue (eq(np.concatenate((x, y)), concatenate((xm, y))))

148

self.assertTrue (eq(np.concatenate((x, y, x)), concatenate((x, ym, x))))

161

149

162

150

def test_xtestCount (self):

163

151

"Test count"

164

152

ott = array([0., 1., 2., 3.], mask=[1, 0, 0, 0])

165

153

if sys.version_info[0] >= 3:

166

self.assertTrue(isinstance(count(ott), numpy.integer))

154

self.assertTrue(isinstance(count(ott), np.integer))

167

155

else:

168

156

self.assertTrue(isinstance(count(ott), int))

169

157

self.assertEqual(3, count(ott))

170

158

self.assertEqual(1, count(1))

171

159

self.assertTrue (eq(0, array(1, mask=[1])))

172

160

ott = ott.reshape((2, 2))

173

assert_(isinstance(count(ott, 0), numpy.ndarray))

161

assert_(isinstance(count(ott, 0), np.ndarray))

174

162

if sys.version_info[0] >= 3:

175

assert_(isinstance(count(ott), numpy.integer))

163

assert_(isinstance(count(ott), np.integer))

176

164

else:

177

165

assert_(isinstance(count(ott), int))

178

166

self.assertTrue (eq(3, count(ott)))

182

170

def test_testMinMax (self):

183

171

"Test minimum and maximum."

184

172

(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d

185

xr = numpy.ravel(x) #max doesn't work if shaped

173

xr = np.ravel(x) #max doesn't work if shaped

186

174

xmr = ravel(xm)

187

175

188

176

#true because of careful selection of data

194

182

def test_testAddSumProd (self):

195

183

"Test add, sum, product."

196

184

(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d

197

self.assertTrue (eq(numpy.add.reduce(x), add.reduce(x)))

198

self.assertTrue (eq(numpy.add.accumulate(x), add.accumulate(x)))

199

self.assertTrue (eq(4, sum(array(4), axis=0)))

200

self.assertTrue (eq(4, sum(array(4), axis=0)))

201

self.assertTrue (eq(numpy.sum(x, axis=0), sum(x, axis=0)))

202

self.assertTrue (eq(numpy.sum(filled(xm, 0), axis=0), sum(xm, axis=0)))

203

self.assertTrue (eq(numpy.sum(x, 0), sum(x, 0)))

204

self.assertTrue (eq(numpy.product(x, axis=0), product(x, axis=0)))

205

self.assertTrue (eq(numpy.product(x, 0), product(x, 0)))

206

self.assertTrue (eq(numpy.product(filled(xm, 1), axis=0),

185

self.assertTrue (eq(np.add.reduce(x), add.reduce(x)))

186

self.assertTrue (eq(np.add.accumulate(x), add.accumulate(x)))

187

self.assertTrue (eq(4, sum(array(4), axis=0)))

188

self.assertTrue (eq(4, sum(array(4), axis=0)))

189

self.assertTrue (eq(np.sum(x, axis=0), sum(x, axis=0)))

190

self.assertTrue (eq(np.sum(filled(xm, 0), axis=0), sum(xm, axis=0)))

191

self.assertTrue (eq(np.sum(x, 0), sum(x, 0)))

192

self.assertTrue (eq(np.product(x, axis=0), product(x, axis=0)))

193

self.assertTrue (eq(np.product(x, 0), product(x, 0)))

194

self.assertTrue (eq(np.product(filled(xm, 1), axis=0),

207

195

product(xm, axis=0)))

208

196

if len(s) > 1:

209

self.assertTrue (eq(numpy.concatenate((x, y), 1),

197

self.assertTrue (eq(np.concatenate((x, y), 1),

210

198

concatenate((xm, ym), 1)))

211

self.assertTrue (eq(numpy.add.reduce(x, 1), add.reduce(x, 1)))

212

self.assertTrue (eq(numpy.sum(x, 1), sum(x, 1)))

213

self.assertTrue (eq(numpy.product(x, 1), product(x, 1)))

199

self.assertTrue (eq(np.add.reduce(x, 1), add.reduce(x, 1)))

200

self.assertTrue (eq(np.sum(x, 1), sum(x, 1)))

201

self.assertTrue (eq(np.product(x, 1), product(x, 1)))

214

202

215

203

216

204

def test_testCI(self):

217

205

"Test of conversions and indexing"

218

x1 = numpy.array([1, 2, 4, 3])

206

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

219

207

x2 = array(x1, mask=[1, 0, 0, 0])

220

208

x3 = array(x1, mask=[0, 1, 0, 1])

221

209

x4 = array(x1)

222

210

# test conversion to strings

223

211

junk, garbage = str(x2), repr(x2)

224

assert_(eq(numpy.sort(x1), sort(x2, fill_value=0)))

212

assert_(eq(np.sort(x1), sort(x2, fill_value=0)))

225

213

# tests of indexing

226

214

assert_(type(x2[1]) is type(x1[1]))

227

215

assert_(x1[1] == x2[1])

248

236

x4[:] = masked_array([1, 2, 3, 4], [0, 1, 1, 0])

249

237

assert_(allequal(getmask(x4), array([0, 1, 1, 0])))

250

238

assert_(allequal(x4, array([1, 2, 3, 4])))

251

x1 = numpy.arange(5) * 1.0

239

x1 = np.arange(5) * 1.0

252

240

x2 = masked_values(x1, 3.0)

253

241

assert_(eq(x1, x2))

254

242

assert_(allequal(array([0, 0, 0, 1, 0], MaskType), x2.mask))

255

243

assert_(eq(3.0, x2.fill_value))

256

244

x1 = array([1, 'hello', 2, 3], object)

257

x2 = numpy.array([1, 'hello', 2, 3], object)

245

x2 = np.array([1, 'hello', 2, 3], object)

258

246

s1 = x1[1]

259

247

s2 = x2[1]

260

248

self.assertEqual(type(s2), str)

271

259

m3 = make_mask(m, copy=1)

272

260

self.assertTrue(m is not m3)

273

261

274

x1 = numpy.arange(5)

262

x1 = np.arange(5)

275

263

y1 = array(x1, mask=m)

276

264

self.assertTrue(y1._data is not x1)

277

265

self.assertTrue(allequal(x1, y1._data))

324

312

def test_testMaPut(self):

325

313

(x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d

326

314

m = [1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1]

327

i = numpy.nonzero(m)[0]

315

i = np.nonzero(m)[0]

328

316

put(ym, i, zm)

329

317

assert_(all(take(ym, i, axis=0) == zm))

330

318

439

427

def test_testTakeTransposeInnerOuter(self):

440

428

"Test of take, transpose, inner, outer products"

441

429

x = arange(24)

442

y = numpy.arange(24)

430

y = np.arange(24)

443

431

x[5:6] = masked

444

432

x = x.reshape(2, 3, 4)

445

433

y = y.reshape(2, 3, 4)

446

assert_(eq(numpy.transpose(y, (2, 0, 1)), transpose(x, (2, 0, 1))))

447

assert_(eq(numpy.take(y, (2, 0, 1), 1), take(x, (2, 0, 1), 1)))

448

assert_(eq(numpy.inner(filled(x, 0), filled(y, 0)),

434

assert_(eq(np.transpose(y, (2, 0, 1)), transpose(x, (2, 0, 1))))

435

assert_(eq(np.take(y, (2, 0, 1), 1), take(x, (2, 0, 1), 1)))

436

assert_(eq(np.inner(filled(x, 0), filled(y, 0)),

449

437

inner(x, y)))

450

assert_(eq(numpy.outer(filled(x, 0), filled(y, 0)),

438

assert_(eq(np.outer(filled(x, 0), filled(y, 0)),

451

439

outer(x, y)))

452

440

y = array(['abc', 1, 'def', 2, 3], object)

453

441

y[2] = masked

557

545

self.assertTrue(allclose(average(x, axis=0, weights=w1), 2.5))

558

546

y = array([arange(6), 2.0 * arange(6)])

559

547

self.assertTrue(allclose(average(y, None),

560

numpy.add.reduce(numpy.arange(6)) * 3. / 12.))

561

self.assertTrue(allclose(average(y, axis=0), numpy.arange(6) * 3. / 2.))

548

np.add.reduce(np.arange(6)) * 3. / 12.))

549

self.assertTrue(allclose(average(y, axis=0), np.arange(6) * 3. / 2.))

562

550

self.assertTrue(allclose(average(y, axis=1),

563

551

[average(x, axis=0), average(x, axis=0) * 2.0]))

564

552

self.assertTrue(allclose(average(y, None, weights=w2), 20. / 6.))

617

605

def test_testScalarArithmetic(self):

618

606

xm = array(0, mask=1)

619

607

#TODO FIXME: Find out what the following raises a warning in r8247

620

err_status = numpy.geterr()

621

try:

622

numpy.seterr(divide='ignore')

608

with np.errstate():

609

np.seterr(divide='ignore')

623

610

self.assertTrue((1 / array(0)).mask)

624

finally:

625

numpy.seterr(**err_status)

626

611

self.assertTrue((1 + xm).mask)

627

612

self.assertTrue((-xm).mask)

628

613

self.assertTrue((-xm).mask)

656

641

self.assertEqual(a.ndim, 1)

657

642

658

643

def test_testAPI(self):

659

self.assertFalse([m for m in dir(numpy.ndarray)

644

self.assertFalse([m for m in dir(np.ndarray)

660

645

if m not in dir(MaskedArray) and not m.startswith('_')])

661

646

662

647

def test_testSingleElementSubscript(self):

699

684

uf = getattr(umath, f)

700

685

except AttributeError:

701

686

uf = getattr(fromnumeric, f)

702

mf = getattr(numpy.ma, f)

687

mf = getattr(np.ma, f)

703

688

args = self.d[:uf.nin]

704

olderr = numpy.geterr()

705

try:

689

with np.errstate():

706

690

if f in f_invalid_ignore:

707

numpy.seterr(invalid='ignore')

691

np.seterr(invalid='ignore')

708

692

if f in ['arctanh', 'log', 'log10']:

709

numpy.seterr(divide='ignore')

693

np.seterr(divide='ignore')

710

694

ur = uf(*args)

711

695

mr = mf(*args)

712

finally:

713

numpy.seterr(**olderr)

714

696

self.assertTrue(eq(ur.filled(0), mr.filled(0), f))

715

697

self.assertTrue(eqmask(ur.mask, mr.mask))

716

698

740

722

class TestArrayMethods(TestCase):

741

723

742

724

def setUp(self):

743

x = numpy.array([ 8.375, 7.545, 8.828, 8.5 , 1.757, 5.928,

725

x = np.array([ 8.375, 7.545, 8.828, 8.5 , 1.757, 5.928,

744

726

8.43 , 7.78 , 9.865, 5.878, 8.979, 4.732,

745

727

3.012, 6.022, 5.095, 3.116, 5.238, 3.957,

746

728

6.04 , 9.63 , 7.712, 3.382, 4.489, 6.479,

749

731

X = x.reshape(6, 6)

750

732

XX = x.reshape(3, 2, 2, 3)

751

733

752

m = numpy.array([0, 1, 0, 1, 0, 0,

734

m = np.array([0, 1, 0, 1, 0, 0,

753

735

1, 0, 1, 1, 0, 1,

754

736

0, 0, 0, 1, 0, 1,

755

737

0, 0, 0, 1, 1, 1,

759

741

mX = array(data=X, mask=m.reshape(X.shape))

760

742

mXX = array(data=XX, mask=m.reshape(XX.shape))

761

743

762

m2 = numpy.array([1, 1, 0, 1, 0, 0,

744

m2 = np.array([1, 1, 0, 1, 0, 0,

763

745

1, 1, 1, 1, 0, 1,

764

746

0, 0, 1, 1, 0, 1,

765

747

0, 0, 0, 1, 1, 1,

789

771

(x, X, XX, m, mx, mX, mXX,) = self.d

790

772

(n, m) = X.shape

791

773

self.assertEqual(mx.ptp(), mx.compressed().ptp())

792

rows = numpy.zeros(n, numpy.float_)

793

cols = numpy.zeros(m, numpy.float_)

774

rows = np.zeros(n, np.float_)

775

cols = np.zeros(m, np.float_)

794

776

for k in range(m):

795

777

cols[k] = mX[:, k].compressed().ptp()

796

778

for k in range(n):

830

812

for k in range(6):

831

813

self.assertTrue(eq(mXvar1[k], mX[k].compressed().var()))

832

814

self.assertTrue(eq(mXvar0[k], mX[:, k].compressed().var()))

833

self.assertTrue(eq(numpy.sqrt(mXvar0[k]),

815

self.assertTrue(eq(np.sqrt(mXvar0[k]),

834

816

mX[:, k].compressed().std()))

835

817

836

818

856

838

#""" % (n, t*1000.0, t1/t, t2/t)

857

839

858

840

#def testta(n, f):

859

# x=numpy.arange(n) + 1.0

841

# x=np.arange(n) + 1.0

860

842

# tn0 = time.time()

861

843

# z = f(x)

862

844

# return time.time() - tn0