TST: add test for random distributions. Closes #1512. · numpy/numpy@898e6bd (original) (raw)

1

from numpy.testing import TestCase, run_module_suite, assert_

1

from numpy.testing import TestCase, run_module_suite, assert_

2

`from numpy import random

3

`import numpy as np

4

`@@ -67,6 +67,362 @@ def test_negative_binomial(self):

67

` """

68

`self.prng.negative_binomial(0.5, 0.5)

69

70

class TestRandomDist(TestCase):

71

""" Make sure the random distrobution return the correct value for a

72

given seed

73

"""

74

def setUp(self):

75

self.seed = 1234567890

76

+

77

def test_rand(self):

78

np.random.seed(self.seed)

79

actual = np.random.rand(3, 2)

80

desired = np.array([[ 0.61879477158567997, 0.59162362775974664],

81

[ 0.88868358904449662, 0.89165480011560816],

82

[ 0.4575674820298663 , 0.7781880808593471 ]])

83

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

84

+

85

def test_randn(self):

86

np.random.seed(self.seed)

87

actual = np.random.randn(3, 2)

88

desired = np.array([[ 1.34016345771863121, 1.73759122771936081],

89

[ 1.498988344300628 , -0.2286433324536169 ],

90

[ 2.031033998682787 , 2.17032494605655257]])

91

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

92

+

93

def test_randint(self):

94

np.random.seed(self.seed)

95

actual = np.random.randint(-99, 99, size=(3,2))

96

desired = np.array([[ 31, 3],

97

[-52, 41],

98

[-48, -66]])

99

np.testing.assert_array_equal(actual, desired)

100

+

101

def test_random_integers(self):

102

np.random.seed(self.seed)

103

actual = np.random.random_integers(-99, 99, size=(3,2))

104

desired = np.array([[ 31, 3],

105

[-52, 41],

106

[-48, -66]])

107

np.testing.assert_array_equal(actual, desired)

108

+

109

def test_random_sample(self):

110

np.random.seed(self.seed)

111

actual = np.random.random_sample((3, 2))

112

desired = np.array([[ 0.61879477158567997, 0.59162362775974664],

113

[ 0.88868358904449662, 0.89165480011560816],

114

[ 0.4575674820298663 , 0.7781880808593471 ]])

115

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

116

+

117

def test_bytes(self):

118

np.random.seed(self.seed)

119

actual = np.random.bytes(10)

120

desired = '\x82Ui\x9e\xff\x97+Wf\xa5'

121

np.testing.assert_string_equal(actual, desired)

122

+

123

def test_shuffle(self):

124

np.random.seed(self.seed)

125

alist = [1,2,3,4,5,6,7,8,9,0]

126

np.random.shuffle(alist)

127

actual = alist

128

desired = [0, 1, 9, 6, 2, 4, 5, 8, 7, 3]

129

np.testing.assert_array_equal(actual, desired)

130

+

131

def test_beta(self):

132

np.random.seed(self.seed)

133

actual = np.random.beta(.1, .9, size=(3, 2))

134

desired = np.array([[ 1.45341850513746058e-02, 5.31297615662868145e-04],

135

[ 1.85366619058432324e-06, 4.19214516800110563e-03],

136

[ 1.58405155108498093e-04, 1.26252891949397652e-04]])

137

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

138

+

139

def test_binomial(self):

140

np.random.seed(self.seed)

141

actual = np.random.binomial(100.123, .456, size=(3, 2))

142

desired = np.array([[37, 43],

143

[42, 48],

144

[46, 45]])

145

np.testing.assert_array_equal(actual, desired)

146

+

147

def test_chisquare(self):

148

np.random.seed(self.seed)

149

actual = np.random.chisquare(50, size=(3, 2))

150

desired = np.array([[ 63.87858175501090585, 68.68407748911370447],

151

[ 65.77116116901505904, 47.09686762438974483],

152

[ 72.3828403199695174 , 74.18408615260374006]])

153

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

154

+

155

def test_dirichlet(self):

156

np.random.seed(self.seed)

157

alpha = np.array([51.72840233779265162, 39.74494232180943953])

158

actual = np.random.mtrand.dirichlet(alpha, size=(3, 2))

159

desired = np.array([[[ 0.54539444573611562, 0.45460555426388438],

160

[ 0.62345816822039413, 0.37654183177960598]],

161

[[ 0.55206000085785778, 0.44793999914214233],

162

[ 0.58964023305154301, 0.41035976694845688]],

163

[[ 0.59266909280647828, 0.40733090719352177],

164

[ 0.56974431743975207, 0.43025568256024799]]])

165

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

166

+

167

def test_exponential(self):

168

np.random.seed(self.seed)

169

actual = np.random.exponential(1.1234, size=(3, 2))

170

desired = np.array([[ 1.08342649775011624, 1.00607889924557314],

171

[ 2.46628830085216721, 2.49668106809923884],

172

[ 0.68717433461363442, 1.69175666993575979]])

173

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

174

+

175

def test_f(self):

176

np.random.seed(self.seed)

177

actual = np.random.f(12, 77, size=(3, 2))

178

desired = np.array([[ 1.21975394418575878, 1.75135759791559775],

179

[ 1.44803115017146489, 1.22108959480396262],

180

[ 1.02176975757740629, 1.34431827623300415]])

181

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

182

+

183

def test_gamma(self):

184

np.random.seed(self.seed)

185

actual = np.random.gamma(5, 3, size=(3, 2))

186

desired = np.array([[ 24.60509188649287182, 28.54993563207210627],

187

[ 26.13476110204064184, 12.56988482927716078],

188

[ 31.71863275789960568, 33.30143302795922011]])

189

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

190

+

191

def test_geometric(self):

192

np.random.seed(self.seed)

193

actual = np.random.geometric(.123456789, size=(3, 2))

194

desired = np.array([[ 8, 7],

195

[17, 17],

196

[ 5, 12]])

197

np.testing.assert_array_equal(actual, desired)

198

+

199

def test_gumbel(self):

200

np.random.seed(self.seed)

201

actual = np.random.gumbel(loc = .123456789, scale = 2.0, size = (3, 2))

202

desired = np.array([[ 0.19591898743416816, 0.34405539668096674],

203

[-1.4492522252274278 , -1.47374816298446865],

204

[ 1.10651090478803416, -0.69535848626236174]])

205

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

206

+

207

def test_hypergeometric(self):

208

np.random.seed(self.seed)

209

actual = np.random.hypergeometric(10.1, 5.5, 14, size=(3, 2))

210

desired = np.array([[10, 10],

211

[10, 10],

212

[ 9, 9]])

213

np.testing.assert_array_equal(actual, desired)

214

+

215

def test_laplace(self):

216

np.random.seed(self.seed)

217

actual = np.random.laplace(loc=.123456789, scale=2.0, size=(3, 2))

218

desired = np.array([[ 0.66599721112760157, 0.52829452552221945],

219

[ 3.12791959514407125, 3.18202813572992005],

220

[-0.05391065675859356, 1.74901336242837324]])

221

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

222

+

223

def test_logistic(self):

224

np.random.seed(self.seed)

225

actual = np.random.logistic(loc=.123456789, scale=2.0, size=(3, 2))

226

desired = np.array([[ 1.09232835305011444, 0.8648196662399954 ],

227

[ 4.27818590694950185, 4.33897006346929714],

228

[-0.21682183359214885, 2.63373365386060332]])

229

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

230

+

231

def test_lognormal(self):

232

np.random.seed(self.seed)

233

actual = np.random.lognormal(mean=.123456789, sigma=2.0, size=(3, 2))

234

desired = np.array([[ 16.50698631688883822, 36.54846706092654784],

235

[ 22.67886599981281748, 0.71617561058995771],

236

[ 65.72798501792723869, 86.84341601437161273]])

237

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

238

+

239

def test_logseries(self):

240

np.random.seed(self.seed)

241

actual = np.random.logseries(p=.923456789, size=(3, 2))

242

desired = np.array([[ 2, 2],

243

[ 6, 17],

244

[ 3, 6]])

245

np.testing.assert_array_equal(actual, desired)

246

+

247

def test_multinomial(self):

248

np.random.seed(self.seed)

249

actual = np.random.multinomial(20, [1/6.]*6, size=(3, 2))

250

desired = np.array([[[4, 3, 5, 4, 2, 2],

251

[5, 2, 8, 2, 2, 1]],

252

[[3, 4, 3, 6, 0, 4],

253

[2, 1, 4, 3, 6, 4]],

254

[[4, 4, 2, 5, 2, 3],

255

[4, 3, 4, 2, 3, 4]]])

256

np.testing.assert_array_equal(actual, desired)

257

+

258

def test_multivariate_normal(self):

259

np.random.seed(self.seed)

260

mean= (.123456789, 10)

261

cov = [[1,0],[1,0]]

262

size = (3, 2)

263

actual = np.random.multivariate_normal(mean, cov, size)

264

desired = np.array([[[ -1.47027513018564449, 10. ],

265

[ -1.65915081534845532, 10. ]],

266

[[ -2.29186329304599745, 10. ],

267

[ -1.77505606019580053, 10. ]],

268

[[ -0.54970369430044119, 10. ],

269

[ 0.29768848031692957, 10. ]]])

270

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

271

+

272

def test_negative_binomial(self):

273

np.random.seed(self.seed)

274

actual = np.random.negative_binomial(n = 100, p = .12345, size = (3, 2))

275

desired = np.array([[848, 841],

276

[892, 611],

277

[779, 647]])

278

np.testing.assert_array_equal(actual, desired)

279

+

280

def test_noncentral_chisquare(self):

281

np.random.seed(self.seed)

282

actual = np.random.noncentral_chisquare(df = 5, nonc = 5, size = (3, 2))

283

desired = np.array([[ 23.91905354498517511, 13.35324692733826346],

284

[ 31.22452661329736401, 16.60047399466177254],

285

[ 5.03461598262724586, 17.94973089023519464]])

286

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

287

+

288

def test_noncentral_f(self):

289

np.random.seed(self.seed)

290

actual = np.random.noncentral_f(dfnum = 5, dfden = 2, nonc = 1,

291

size = (3, 2))

292

desired = np.array([[ 1.40598099674926669, 0.34207973179285761],

293

[ 3.57715069265772545, 7.92632662577829805],

294

[ 0.43741599463544162, 1.1774208752428319 ]])

295

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

296

+

297

def test_normal(self):

298

np.random.seed(self.seed)

299

actual = np.random.normal(loc = .123456789, scale = 2.0, size = (3, 2))

300

desired = np.array([[ 2.80378370443726244, 3.59863924443872163],

301

[ 3.121433477601256 , -0.33382987590723379],

302

[ 4.18552478636557357, 4.46410668111310471]])

303

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

304

+

305

def test_pareto(self):

306

np.random.seed(self.seed)

307

actual = np.random.pareto(a =.123456789, size = (3, 2))

308

desired = np.array([[ 2.46852460439034849e+03, 1.41286880810518346e+03],

309

[ 5.28287797029485181e+07, 6.57720981047328785e+07],

310

[ 1.40840323350391515e+02, 1.98390255135251704e+05]])

311

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

312

+

313

def test_poisson(self):

314

np.random.seed(self.seed)

315

actual = np.random.poisson(lam = .123456789, size=(3, 2))

316

desired = np.array([[0, 0],

317

[1, 0],

318

[0, 0]])

319

np.testing.assert_array_equal(actual, desired)

320

+

321

def test_power(self):

322

np.random.seed(self.seed)

323

actual = np.random.power(a =.123456789, size = (3, 2))

324

desired = np.array([[ 0.02048932883240791, 0.01424192241128213],

325

[ 0.38446073748535298, 0.39499689943484395],

326

[ 0.00177699707563439, 0.13115505880863756]])

327

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

328

+

329

def test_rayleigh(self):

330

np.random.seed(self.seed)

331

actual = np.random.rayleigh(scale = 10, size = (3, 2))

332

desired = np.array([[ 13.8882496494248393 , 13.383318339044731 ],

333

[ 20.95413364294492098, 21.08285015800712614],

334

[ 11.06066537006854311, 17.35468505778271009]])

335

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

336

+

337

def test_standard_cauchy(self):

338

np.random.seed(self.seed)

339

actual = np.random.standard_cauchy(size = (3, 2))

340

desired = np.array([[ 0.77127660196445336, -6.55601161955910605],

341

[ 0.93582023391158309, -2.07479293013759447],

342

[-4.74601644297011926, 0.18338989290760804]])

343

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

344

+

345

def test_standard_exponential(self):

346

np.random.seed(self.seed)

347

actual = np.random.standard_exponential(size = (3, 2))

348

desired = np.array([[ 0.96441739162374596, 0.89556604882105506],

349

[ 2.1953785836319808 , 2.22243285392490542],

350

[ 0.6116915921431676 , 1.50592546727413201]])

351

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

352

+

353

def test_standard_gamma(self):

354

np.random.seed(self.seed)

355

actual = np.random.standard_gamma(shape = 3, size = (3, 2))

356

desired = np.array([[ 5.50841531318455058, 6.62953470301903103],

357

[ 5.93988484943779227, 2.31044849402133989],

358

[ 7.54838614231317084, 8.012756093271868 ]])

359

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

360

+

361

def test_standard_normal(self):

362

np.random.seed(self.seed)

363

actual = np.random.standard_normal(size = (3, 2))

364

desired = np.array([[ 1.34016345771863121, 1.73759122771936081],

365

[ 1.498988344300628 , -0.2286433324536169 ],

366

[ 2.031033998682787 , 2.17032494605655257]])

367

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

368

+

369

def test_standard_t(self):

370

np.random.seed(self.seed)

371

actual = np.random.standard_t(df = 10, size = (3, 2))

372

desired = np.array([[ 0.97140611862659965, -0.08830486548450577],

373

[ 1.36311143689505321, -0.55317463909867071],

374

[-0.18473749069684214, 0.61181537341755321]])

375

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

376

+

377

def test_triangular(self):

378

np.random.seed(self.seed)

379

actual = np.random.triangular(left = 5.12, mode = 10.23, right = 20.34,

380

size = (3, 2))

381

desired = np.array([[ 12.68117178949215784, 12.4129206149193152 ],

382

[ 16.20131377335158263, 16.25692138747600524],

383

[ 11.20400690911820263, 14.4978144835829923 ]])

384

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

385

+

386

def test_uniform(self):

387

np.random.seed(self.seed)

388

actual = np.random.uniform(low = 1.23, high=10.54, size = (3, 2))

389

desired = np.array([[ 6.99097932346268003, 6.73801597444323974],

390

[ 9.50364421400426274, 9.53130618907631089],

391

[ 5.48995325769805476, 8.47493103280052118]])

392

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

393

+

394

+

395

def test_vonmises(self):

396

np.random.seed(self.seed)

397

actual = np.random.vonmises(mu = 1.23, kappa = 1.54, size = (3, 2))

398

desired = np.array([[ 2.28567572673902042, 2.89163838442285037],

399

[ 0.38198375564286025, 2.57638023113890746],

400

[ 1.19153771588353052, 1.83509849681825354]])

401

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

402

+

403

def test_wald(self):

404

np.random.seed(self.seed)

405

actual = np.random.wald(mean = 1.23, scale = 1.54, size = (3, 2))

406

desired = np.array([[ 3.82935265715889983, 5.13125249184285526],

407

[ 0.35045403618358717, 1.50832396872003538],

408

[ 0.24124319895843183, 0.22031101461955038]])

409

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

410

+

411

def test_weibull(self):

412

np.random.seed(self.seed)

413

actual = np.random.weibull(a = 1.23, size = (3, 2))

414

desired = np.array([[ 0.97097342648766727, 0.91422896443565516],

415

[ 1.89517770034962929, 1.91414357960479564],

416

[ 0.67057783752390987, 1.39494046635066793]])

417

np.testing.assert_array_almost_equal(actual, desired, decimal=15)

418

+

419

def test_zipf(self):

420

np.random.seed(self.seed)

421

actual = np.random.zipf(a = 1.23, size = (3, 2))

422

desired = np.array([[66, 29],

423

[ 1, 1],

424

[ 3, 13]])

425

np.testing.assert_array_equal(actual, desired)

70

426

71

427

`if name == "main":

72

428

`run_module_suite()