def test_testPut2(self): # Test of put d = arange(5) x = array(d, mask=[0, 0, 0, 0, 0]) z = array([10, 40], mask=[1, 0]) assert_(x[2] is not masked) assert_(x[3] is not masked) x[2:4] = z assert_(x[2] is masked) assert_(x[3] is not masked) assert_(eq(x, [0, 1, 10, 40, 4])) d = arange(5) x = array(d, mask=[0, 0, 0, 0, 0]) y = x[2:4] z = array([10, 40], mask=[1, 0]) assert_(x[2] is not masked) assert_(x[3] is not masked) y[:] = z assert_(y[0] is masked) assert_(y[1] is not masked) assert_(eq(y, [10, 40])) assert_(x[2] is masked) assert_(x[3] is not masked) assert_(eq(x, [0, 1, 10, 40, 4]))
def test_testAverage2(self): # More tests of average. w1 = [0, 1, 1, 1, 1, 0] w2 = [[0, 1, 1, 1, 1, 0], [1, 0, 0, 0, 0, 1]] x = arange(6) assert_(allclose(average(x, axis=0), 2.5)) assert_(allclose(average(x, axis=0, weights=w1), 2.5)) y = array([arange(6), 2.0 * arange(6)]) assert_(allclose(average(y, None), np.add.reduce(np.arange(6)) * 3. / 12.)) assert_(allclose(average(y, axis=0), np.arange(6) * 3. / 2.)) assert_(allclose(average(y, axis=1), [average(x, axis=0), average(x, axis=0)*2.0])) assert_(allclose(average(y, None, weights=w2), 20. / 6.)) assert_(allclose(average(y, axis=0, weights=w2), [0., 1., 2., 3., 4., 10.])) assert_(allclose(average(y, axis=1), [average(x, axis=0), average(x, axis=0)*2.0])) m1 = zeros(6) m2 = [0, 0, 1, 1, 0, 0] m3 = [[0, 0, 1, 1, 0, 0], [0, 1, 1, 1, 1, 0]] m4 = ones(6) m5 = [0, 1, 1, 1, 1, 1] assert_(allclose(average(masked_array(x, m1), axis=0), 2.5)) assert_(allclose(average(masked_array(x, m2), axis=0), 2.5)) assert_(average(masked_array(x, m4), axis=0) is masked) assert_equal(average(masked_array(x, m5), axis=0), 0.0) assert_equal(count(average(masked_array(x, m4), axis=0)), 0) z = masked_array(y, m3) assert_(allclose(average(z, None), 20. / 6.)) assert_(allclose(average(z, axis=0), [0., 1., 99., 99., 4.0, 7.5])) assert_(allclose(average(z, axis=1), [2.5, 5.0])) assert_(allclose(average(z, axis=0, weights=w2), [0., 1., 99., 99., 4.0, 10.0])) a = arange(6) b = arange(6) * 3 r1, w1 = average([[a, b], [b, a]], axis=1, returned=1) assert_equal(shape(r1), shape(w1)) assert_equal(r1.shape, w1.shape) r2, w2 = average(ones((2, 2, 3)), axis=0, weights=[3, 1], returned=1) assert_equal(shape(w2), shape(r2)) r2, w2 = average(ones((2, 2, 3)), returned=1) assert_equal(shape(w2), shape(r2)) r2, w2 = average(ones((2, 2, 3)), weights=ones((2, 2, 3)), returned=1) assert_(shape(w2) == shape(r2)) a2d = array([[1, 2], [0, 4]], float) a2dm = masked_array(a2d, [[0, 0], [1, 0]]) a2da = average(a2d, axis=0) assert_(eq(a2da, [0.5, 3.0])) a2dma = average(a2dm, axis=0) assert_(eq(a2dma, [1.0, 3.0])) a2dma = average(a2dm, axis=None) assert_(eq(a2dma, 7. / 3.)) a2dma = average(a2dm, axis=1) assert_(eq(a2dma, [1.5, 4.0]))
def test_testMinMax2(self): # Test of minimum, maximum. assert_(eq(minimum([1, 2, 3], [4, 0, 9]), [1, 0, 3])) assert_(eq(maximum([1, 2, 3], [4, 0, 9]), [4, 2, 9])) x = arange(5) y = arange(5) - 2 x[3] = masked y[0] = masked assert_(eq(minimum(x, y), where(less(x, y), x, y))) assert_(eq(maximum(x, y), where(greater(x, y), x, y))) assert_(minimum.reduce(x) == 0) assert_(maximum.reduce(x) == 4)
def self_training(X, y, X_unLabeled, clf, th): clf.fit(X=X, y=y) index_unlabeled = ma.arange(0, len(X_unLabeled), 1) y_unlabeled = np.zeros(len(X_unLabeled)) train_is_failed = False while True: probs = clf.predict_proba(X=X_unLabeled[~ma.getmaskarray(index_unlabeled)]) index_greater_equal = np.greater_equal([max(d) for d in probs], [th]*len(probs)) index_labelable = index_unlabeled.data[~ma.getmaskarray(index_unlabeled)][index_greater_equal] if not len(index_labelable) > 0: if not len(index_unlabeled.data[ma.getmaskarray(index_unlabeled)]) > 0: train_is_failed = True break index_unlabeled[index_labelable] = ma.masked if index_unlabeled.all() is ma.masked: break y_unlabeled[index_labelable] = [np.argmax(p) for p in probs[index_greater_equal]] X_labelable = X_unLabeled[index_unlabeled.mask] y_labelable = y_unlabeled[index_unlabeled.mask] clf.fit(X=np.append(X, X_labelable, axis=0), y=np.append(y, y_labelable)) if train_is_failed: y_unlabeled = [] else: y_unlabeled = ma.array(data=y_unlabeled, mask=index_unlabeled.mask) return clf, y_unlabeled
def solve_equation(k, m, x0, xk, n, h, t, w, x, solver, method_name, draw_flag): solver(k, m, x0, xk, n, h, t, w, x) xx = arange(x0, xk, 0.1) f_y = [] for i in x: f_y.append(calculate_f_x_1(i, k, m)) mean_square_error = calculate_mean_square_error(x, f_y, w) max_error = calculate_max_norm(x, f_y, w) mean_format = "{:.4f}" max_format = "{:.4f}" if mean_square_error < 0.0001: mean_format = "{:.3e}" elif mean_square_error > 100: mean_format = "{:.0f}" if max_error < 0.0001: max_format = "{:.3e}" elif max_error > 100: max_format = "{:.0f}" print(";".join((str(n), mean_format.format(mean_square_error), max_format.format(max_error)))) if draw_flag: add_to_plot(xx, calculate_f_x_1(xx, k, m), "Given function") add_to_plot(x, w, method_name + " differential") file_name = method_name + "_" + str(n) title = ( method_name + " n = " + str(n) + "\n mean square error = " + mean_format.format(mean_square_error) + "\n max error = " + max_format.format(max_error) ) draw_plot(title, file_name)
def test_testMasked(self): # Test of masked element xx = arange(6) xx[1] = masked self.assertTrue(str(masked) == '--') self.assertTrue(xx[1] is masked) self.assertEqual(filled(xx[1], 0), 0)
def plotBestFit(weights): import matplotlib.pyplot as plt dataMat, labelMat = loadDataSet() dataArr = array(dataMat) n = shape(dataArr)[0] xcord1 = [] ycord1 = [] xcord2 = [] ycord2 = [] for i in range(n): if int(labelMat[i]) == 1: xcord1.append(dataArr[i, 1]) ycord1.append(dataArr[i, 2]) else: xcord2.append(dataArr[i, 1]) ycord2.append(dataArr[i, 2]) fig = plt.figure() ax = fig.add_subplot(111) ax.scatter(xcord1, ycord1, s=30, c='red', marker='s') ax.scatter(xcord2, ycord2, s=30, c='green') x = arange(-3.0, 3.0, 0.1) y = (-weights[0] - weights[1] * x) / weights[2] ax.plot(x, y) plt.xlabel('X') plt.ylabel('Y') plt.show()
def test_masked_1d_single(self): data = ma.arange(11) data[3:7] = ma.masked actual = PERCENTILE.aggregate(data, axis=0, percent=50) expected = 7 self.assertTupleEqual(actual.shape, ()) self.assertEqual(actual, expected)
def brute_force(f, a, b, segments): x0 = a x1 = b dx = (x1 - x0) / segments fs = map(lambda _x: (_x, f(_x)), arange(x0, x1, dx)) return min(fs, key=lambda xf: abs(xf[1]))
def test_pearsonr(self): # Tests some computations of Pearson's r x = ma.arange(10) with warnings.catch_warnings(): # The tests in this context are edge cases, with perfect # correlation or anticorrelation, or totally masked data. # None of these should trigger a RuntimeWarning. warnings.simplefilter("error", RuntimeWarning) assert_almost_equal(mstats.pearsonr(x, x)[0], 1.0) assert_almost_equal(mstats.pearsonr(x, x[::-1])[0], -1.0) x = ma.array(x, mask=True) pr = mstats.pearsonr(x, x) assert_(pr[0] is masked) assert_(pr[1] is masked) x1 = ma.array([-1.0, 0.0, 1.0]) y1 = ma.array([0, 0, 3]) r, p = mstats.pearsonr(x1, y1) assert_almost_equal(r, np.sqrt(3)/2) assert_almost_equal(p, 1.0/3) # (x2, y2) have the same unmasked data as (x1, y1). mask = [False, False, False, True] x2 = ma.array([-1.0, 0.0, 1.0, 99.0], mask=mask) y2 = ma.array([0, 0, 3, -1], mask=mask) r, p = mstats.pearsonr(x2, y2) assert_almost_equal(r, np.sqrt(3)/2) assert_almost_equal(p, 1.0/3)
def grid_linefit(grid, timevals=None, timeslice=slice(None, None, None)): """A compressed spatiotemporal grid is provided. A line fit is performed along the time axis for each spatial cell. Two grids are returned, each of which is 2d, with the same spatial shape as the input. The pixels of one grid contains the slope, the other contains the r squared value of the line fit for that spatial cell. A vector of time values may be provided. If not supplied, one will be generated.""" if timevals == None: timevals = ma.arange(grid.shape[0]) X = sm.add_constant(timevals, prepend=True) outshape = (grid.shape[1],) rsq_map = ma.zeros(outshape) slope_map = ma.zeros(outshape) for i in range(outshape[0]): if (i % 1000) == 0: print "%d of %d (%f)" % (i, outshape[0], (i * 100.0) / outshape[0]) if (type(grid) == "numpy.ma.core.MaskedArray") and grid[0, :].mask[i]: rsq_map[i] = ma.masked slope_map[i] = ma.masked else: m, rsq = linefit(grid, i, X, timeslice) rsq_map[i] = rsq slope_map[i] = m return (slope_map, rsq_map)
def test_testMasked(self): # Test of masked element xx = arange(6) xx[1] = masked assert_(str(masked) == '--') assert_(xx[1] is masked) assert_equal(filled(xx[1], 0), 0)
def test_multi(self): for dtype in [np.int, np.float]: data = ma.arange(12, dtype=dtype) data[::2] = ma.masked self._check(data.reshape(3, 4)) data = ma.arange(12, dtype=dtype) data[1::2] = ma.masked self._check(data.reshape(3, 4)) data = ma.arange(12, dtype=dtype).reshape(3, 4) data[::2] = ma.masked self._check(data) data = ma.arange(12, dtype=dtype).reshape(3, 4) data[1::2] = ma.masked self._check(data)
def test_masked_1d_multi(self): data = ma.arange(11) data[3:9] = ma.masked percent = np.array([25, 50, 75]) actual = PERCENTILE.aggregate(data, axis=0, percent=percent) expected = [1, 2, 9] self.assertTupleEqual(actual.shape, percent.shape) self.assertArrayEqual(actual, expected)
def test_scalar_mask(self): # Testing the bug raised in https://github.com/SciTools/iris/pull/123#issuecomment-9309872 # (the fix workaround for the np.append bug failed for scalar masks) cube = tests.stock.realistic_4d_w_missing_data() cube.data = ma.arange(np.product(cube.shape), dtype=np.float32).reshape(cube.shape) cube.coord('grid_longitude').circular = True # There's no result to test, just make sure we don't cause an exception with the scalar mask. _ = iris.analysis.interpolate.linear(cube, [('grid_longitude', 0), ('grid_latitude', 0)])
def test_trim(self): a = ma.arange(10) assert_equal(mstats.trim(a), [0,1,2,3,4,5,6,7,8,9]) a = ma.arange(10) assert_equal(mstats.trim(a,(2,8)), [None,None,2,3,4,5,6,7,8,None]) a = ma.arange(10) assert_equal(mstats.trim(a,limits=(2,8),inclusive=(False,False)), [None,None,None,3,4,5,6,7,None,None]) a = ma.arange(10) assert_equal(mstats.trim(a,limits=(0.1,0.2),relative=True), [None,1,2,3,4,5,6,7,None,None]) a = ma.arange(12) a[[0,-1]] = a[5] = masked assert_equal(mstats.trim(a,(2,8)), [None,None,2,3,4,None,6,7,8,None,None,None]) x = ma.arange(100).reshape(10,10) trimx = mstats.trim(x,(0.1,0.2),relative=True,axis=None) assert_equal(trimx._mask.ravel(),[1]*10+[0]*70+[1]*20) trimx = mstats.trim(x,(0.1,0.2),relative=True,axis=0) assert_equal(trimx._mask.ravel(),[1]*10+[0]*70+[1]*20) trimx = mstats.trim(x,(0.1,0.2),relative=True,axis=-1) assert_equal(trimx._mask.T.ravel(),[1]*10+[0]*70+[1]*20) x = ma.arange(110).reshape(11,10) x[1] = masked trimx = mstats.trim(x,(0.1,0.2),relative=True,axis=None) assert_equal(trimx._mask.ravel(),[1]*20+[0]*70+[1]*20) trimx = mstats.trim(x,(0.1,0.2),relative=True,axis=0) assert_equal(trimx._mask.ravel(),[1]*20+[0]*70+[1]*20) trimx = mstats.trim(x.T,(0.1,0.2),relative=True,axis=-1) assert_equal(trimx.T._mask.ravel(),[1]*20+[0]*70+[1]*20)
def test_hdmedian(): # 1-D array x = ma.arange(11) assert_allclose(ms.hdmedian(x), 5, rtol=1e-14) x.mask = ma.make_mask(x) x.mask[:7] = False assert_allclose(ms.hdmedian(x), 3, rtol=1e-14) # Check that `var` keyword returns a value. TODO: check whether returned # value is actually correct. assert_(ms.hdmedian(x, var=True).size == 2) # 2-D array x2 = ma.arange(22).reshape((11, 2)) assert_allclose(ms.hdmedian(x2, axis=0), [10, 11]) x2.mask = ma.make_mask(x2) x2.mask[:7, :] = False assert_allclose(ms.hdmedian(x2, axis=0), [6, 7])
def test_testPickle(self): # Test of pickling x = arange(12) x[4:10:2] = masked x = x.reshape(4, 3) for proto in range(2, pickle.HIGHEST_PROTOCOL + 1): s = pickle.dumps(x, protocol=proto) y = pickle.loads(s) assert_(eq(x, y))
def recursive_brute_force(f, a, b, segments=10, recursions=10, epsilon=1e-5): x0 = a x1 = b dx = (x1 - x0) / segments for _ in arange(0, recursions, 1): fs = map(lambda _x: (_x, f(_x)), arange(x0, x1, dx)) x, _f = min(fs, key=lambda xf: abs(xf[1])) print(x, _f) if abs(_f) < epsilon: return x, _f x0 = x - dx x1 = x + dx dx = (x1 - x0) / segments return x, _f
def setUp(self): self.data = ma.arange(12).reshape(3, 4) self.data.mask = [[0, 0, 0, 1], [0, 0, 1, 1], [0, 1, 1, 1]] # --> fractions of masked-points in columns = [0, 1/3, 2/3, 1] self.array = as_lazy_data(self.data) self.axis = 0 self.expected_masked = ma.mean(self.data, axis=self.axis)
def test_testPickle(self): # Test of pickling import pickle x = arange(12) x[4:10:2] = masked x = x.reshape(4, 3) s = pickle.dumps(x) y = pickle.loads(s) assert_(eq(x, y))
def test_minmax(self): a = arange(1, 13).reshape(3, 4) amask = masked_where(a < 5, a) assert_equal(amask.max(), a.max()) assert_equal(amask.min(), 5) assert_((amask.max(0) == a.max(0)).all()) assert_((amask.min(0) == [5, 6, 7, 8]).all()) assert_(amask.max(1)[0].mask) assert_(amask.min(1)[0].mask)
def test_flat(self): for dtype in [np.int, np.float]: data = ma.arange(12, dtype=dtype) data[::2] = ma.masked self._check(data) data.mask = ma.nomask data[1::2] = ma.masked self._check(data)
def test_masked_1d_multi(self): data = ma.arange(11) weights = np.ones(data.shape) data[3:9] = ma.masked percent = np.array([25, 50, 75]) actual = WPERCENTILE.aggregate(data, axis=0, percent=percent, weights=weights) expected = [0.75, 2, 9.25] self.assertTupleEqual(actual.shape, percent.shape) self.assertArrayAlmostEqual(actual, expected)
def test_pearsonr(self): "Tests some computations of Pearson's r" x = ma.arange(10) assert_almost_equal(mstats.pearsonr(x,x)[0], 1.0) assert_almost_equal(mstats.pearsonr(x,x[::-1])[0], -1.0) # x = ma.array(x, mask=True) pr = mstats.pearsonr(x,x) assert(pr[0] is masked) assert(pr[1] is masked)
def test_masked_2d_single(self): shape = (2, 11) data = ma.arange(np.prod(shape)).reshape(shape) data[0, ::2] = ma.masked data[1, 1::2] = ma.masked actual = PERCENTILE.aggregate(data, axis=0, percent=50) self.assertTupleEqual(actual.shape, shape[-1:]) expected = np.empty(shape[-1:]) expected[1::2] = data[0, 1::2] expected[::2] = data[1, ::2] self.assertArrayEqual(actual, expected)
def test_masked_2d_multi(self): shape = (3, 10) data = ma.arange(np.prod(shape)).reshape(shape) data[1] = ma.masked percent = np.array([10, 50, 70, 80]) actual = PERCENTILE.aggregate(data, axis=0, percent=percent) self.assertTupleEqual(actual.shape, (shape[-1], percent.size)) expected = np.tile(np.arange(shape[-1]), percent.size) expected = expected.reshape(percent.size, shape[-1]).T expected = expected + (percent / 10 * 2) self.assertArrayAlmostEqual(actual, expected)
def test_trim_old(self): x = ma.arange(100) assert_equal(mstats.trimboth(x).count(), 60) assert_equal(mstats.trimtail(x,tail='r').count(), 80) x[50:70] = masked trimx = mstats.trimboth(x) assert_equal(trimx.count(), 48) assert_equal(trimx._mask, [1]*16 + [0]*34 + [1]*20 + [0]*14 + [1]*16) x._mask = nomask x.shape = (10,10) assert_equal(mstats.trimboth(x).count(), 60) assert_equal(mstats.trimtail(x).count(), 80)
def test_forward_fill(self): x = ma.arange(20) x[(x%5 != 0)] = masked # Test forward_fill w/o gaps, starting unmasked test = forward_fill(x) assert_equal(test, [ 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 10,10,10,10,10,15,15,15,15,15]) # Test forward_fill w/ gaps, starting unmasked test = forward_fill(x, 3) assert_equal(test, x) assert_equal(test._mask, x._mask) # Test forward_fill w/ gaps, starting unmasked x[[3,4]] = (3,4) test = forward_fill(x, 3) assert_equal(test, [ 0, 0, 0, 3, 4, 5, 5, 5, 5, 5, 10,10,10,10,10,15,15,15,15,15,]) assert_equal(test._mask,[0,0,0,0,0,0,1,1,1,1, 0,1,1,1,1,0,1,1,1,1,]) # Test forward_fill w/o gaps, starting masked x[[0,3,4]] = masked test = forward_fill(x) assert_equal(test, [ 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 10,10,10,10,10,15,15,15,15,15]) assert_equal(test._mask, [1,1,1,1,1,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,]) # Test forward_fill w/ gaps, starting masked test = forward_fill(x,3) assert_equal(test, [ 0, 0, 0, 0, 0, 5, 5, 5, 5, 5, 10,10,10,10,10,15,15,15,15,15]) assert_equal(test._mask, [1,1,1,1,1,0,1,1,1,1, 0,1,1,1,1,0,1,1,1,1,]) # Test forward_fill w/o gaps, starting masked, ending unmasked x[:].mask = False x[0] = masked test = forward_fill(x) assert_equal(test, ma.arange(20)) assert_equal(test._mask, [1,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,])
def test_realised_dtype_none(self): shape = (2, 3, 4) size = np.prod(shape) mask_array = ma.arange(size).reshape(shape) dtype = mask_array.dtype lazy_array = as_lazy_data(mask_array) dm = DataManager(lazy_array, realised_dtype=dtype) self.assertIsNone(dm._realised_dtype) self.assertEqual(dm.dtype, dtype) dm.data = mask_array self.assertIs(dm.data, mask_array) self.assertIsNone(dm._realised_dtype) self.assertEqual(dm.dtype, dtype)
def test_testCopySize(self): # Tests of some subtle points of copying and sizing. with suppress_warnings() as sup: sup.filter( np.ma.core.MaskedArrayFutureWarning, "setting an item on a masked array which has a " "shared mask will not copy") n = [0, 0, 1, 0, 0] m = make_mask(n) m2 = make_mask(m) self.assertTrue(m is m2) m3 = make_mask(m, copy=1) self.assertTrue(m is not m3) x1 = np.arange(5) y1 = array(x1, mask=m) self.assertTrue(y1._data is not x1) self.assertTrue(allequal(x1, y1._data)) self.assertTrue(y1.mask is m) y1a = array(y1, copy=0) self.assertTrue(y1a.mask is y1.mask) y2 = array(x1, mask=m, copy=0) self.assertTrue(y2.mask is m) self.assertTrue(y2[2] is masked) y2[2] = 9 self.assertTrue(y2[2] is not masked) self.assertTrue(y2.mask is not m) self.assertTrue(allequal(y2.mask, 0)) y3 = array(x1 * 1.0, mask=m) self.assertTrue(filled(y3).dtype is (x1 * 1.0).dtype) x4 = arange(4) x4[2] = masked y4 = resize(x4, (8, )) self.assertTrue(eq(concatenate([x4, x4]), y4)) self.assertTrue(eq(getmask(y4), [0, 0, 1, 0, 0, 0, 1, 0])) y5 = repeat(x4, (2, 2, 2, 2), axis=0) self.assertTrue(eq(y5, [0, 0, 1, 1, 2, 2, 3, 3])) y6 = repeat(x4, 2, axis=0) self.assertTrue(eq(y5, y6))
def test_testPut(self): # Test of put d = arange(5) n = [0, 0, 0, 1, 1] m = make_mask(n) x = array(d, mask=m) self.assertTrue(x[3] is masked) self.assertTrue(x[4] is masked) x[[1, 4]] = [10, 40] self.assertTrue(x.mask is not m) self.assertTrue(x[3] is masked) self.assertTrue(x[4] is not masked) self.assertTrue(eq(x, [0, 10, 2, -1, 40])) x = array(d, mask=m) x.put([0, 1, 2], [-1, 100, 200]) self.assertTrue(eq(x, [-1, 100, 200, 0, 0])) self.assertTrue(x[3] is masked) self.assertTrue(x[4] is masked)
def test_testTakeTransposeInnerOuter(self): # Test of take, transpose, inner, outer products x = arange(24) y = np.arange(24) x[5:6] = masked x = x.reshape(2, 3, 4) y = y.reshape(2, 3, 4) assert_(eq(np.transpose(y, (2, 0, 1)), transpose(x, (2, 0, 1)))) assert_(eq(np.take(y, (2, 0, 1), 1), take(x, (2, 0, 1), 1))) assert_(eq(np.inner(filled(x, 0), filled(y, 0)), inner(x, y))) assert_(eq(np.outer(filled(x, 0), filled(y, 0)), outer(x, y))) y = array(['abc', 1, 'def', 2, 3], object) y[2] = masked t = take(y, [0, 3, 4]) assert_(t[0] == 'abc') assert_(t[1] == 2) assert_(t[2] == 3)
def test_known_with_masked(self): dims = self.Blocks[0].dims data = ma.ones(dims) * sp.arange(1, dims[-1] + 1) data[0:-1:2, 0, 0, :] = 2 * sp.arange(1, dims[-1] + 1) for Data in self.Blocks: Data.data = data self.Blocks[0].data[2, 0, 0, 43] = ma.masked self.Blocks[0].data[7, 0, 0, 43] = ma.masked self.Blocks[1].data[4, 0, 0, 43] = ma.masked self.Blocks[1].data[3, 0, 0, 43] = ma.masked self.Blocks[0].data[:, 0, 0, 103] = ma.masked self.Blocks[1].data[:, 0, 0, 103] = ma.masked self.Blocks[0].data[:, 0, 0, 554] = ma.masked self.Blocks[1].data[1:, 0, 0, 554] = ma.masked var = tools.calc_time_var_file(self.Blocks, 0, 0) expected = ma.arange(1, dims[-1] + 1)**2 / 4.0 expected[103] = ma.masked expected[554] = ma.masked self.assertTrue(sp.allclose(var.filled(-1), expected.filled(-1)))
def test_GridToMeshESMFRegridder_curvilinear_round_trip(tmp_path): """Test save/load round tripping for `GridToMeshESMFRegridder`.""" original_rg, src = _make_grid_to_mesh_regridder(grid_dims=2) filename = tmp_path / "regridder.nc" save_regridder(original_rg, filename) loaded_rg = load_regridder(str(filename)) assert original_rg.grid_x == loaded_rg.grid_x assert original_rg.grid_y == loaded_rg.grid_y # Demonstrate regridding still gives the same results. src_data = ma.arange(np.product(src.data.shape)).reshape(src.data.shape) src_data[0, 0] = ma.masked src.data = src_data # TODO: make this a cube comparison when mesh comparison becomes available. original_result = original_rg(src).data loaded_result = loaded_rg(src).data assert np.array_equal(original_result, loaded_result) assert np.array_equal(original_result.mask, loaded_result.mask)
def ReadFile(id): x_axis = [] y_axis = [] w = 6 bound = id + 1 * w for i in range(id, bound, 1): col = [] f = open(exp_dir + "/results/timestamps/PRJ_{}.txt".format(i), "r") read = f.readlines() for r in read: value = double(r.strip("\n")) # timestamp. col.append(value) # calculate the proportional values of samples coly = 1. * arange(len(col)) / (len(col) - 1) x_axis.append(col) y_axis.append(coly) return x_axis, y_axis
def histo_plot(self, yaxis, labels): _ = self xaxis = arange(0.0, len(labels), 1.0) # xaxis = [1.0 * x for x in range(0, len(labels))] fig = plt.figure() fig.suptitle('Corpora Pattern Count', fontsize=14, fontweight='bold') ax = fig.add_subplot(111) fig.subplots_adjust(top=0.92, left=0.05, right=0.98, bottom=0.08) ax.set_xticklabels(labels) plt.xticks(xaxis) # axes = plt.gca() # axes.set_ylim([COUNT_MIN, COUNT_MAX]) ax.set_xlabel('patterns') ax.set_ylabel('count') plt.xticks(rotation=90) for xoff, (ydata, ycolor) in enumerate(zip(yaxis, list("rgbmyc"))): ax.bar(xaxis + 0.2 * xoff, ydata, width=0.2, color=ycolor) show()
def test_masked_2d_multi_unequal(self): shape = (3, 10) data = ma.arange(np.prod(shape)).reshape(shape) weights = np.ones(shape) weights[0] = 3 data[1] = ma.masked percent = np.array([30, 50, 75, 80]) actual, weight_total = WPERCENTILE.aggregate(data, axis=0, percent=percent, weights=weights, returned=True) self.assertTupleEqual(actual.shape, (shape[-1], percent.size)) expected = np.tile(np.arange(shape[-1]), percent.size) expected = expected.reshape(percent.size, shape[-1]).T expected[:, 1:] = 2.0 * ( (0.875 - percent[1:] / 100.0) * data[0, np.newaxis].T + (percent[1:] / 100.0 - 0.375) * data[-1, np.newaxis].T) self.assertArrayAlmostEqual(actual, expected) self.assertTupleEqual(weight_total.shape, (shape[-1], )) self.assertArrayEqual(weight_total, np.repeat(4, shape[-1]))
def test_testPut(self): # Test of put d = arange(5) n = [0, 0, 0, 1, 1] m = make_mask(n) m2 = m.copy() x = array(d, mask=m) assert_(x[3] is masked) assert_(x[4] is masked) x[[1, 4]] = [10, 40] assert_(x._mask is m) assert_(x[3] is masked) assert_(x[4] is not masked) assert_(eq(x, [0, 10, 2, -1, 40])) x = array(d, mask=m2, copy=True) x.put([0, 1, 2], [-1, 100, 200]) assert_(x._mask is not m2) assert_(x[3] is masked) assert_(x[4] is masked) assert_(eq(x, [-1, 100, 200, 0, 0]))
def _interpolate(the_test): """ Interpolate the road points using cubic splines and ensure we handle 4F tuples for compatibility """ old_x_vals = [t[0] for t in the_test] old_y_vals = [t[1] for t in the_test] # This is an approximation based on whatever input is given test_road_lenght = LineString([(t[0], t[1]) for t in the_test]).length num_nodes = int(test_road_lenght / interpolation_distance) if num_nodes < min_num_nodes: num_nodes = min_num_nodes assert len( old_x_vals) >= 2, "You need at leas two road points to define a road" assert len( old_y_vals) >= 2, "You need at leas two road points to define a road" if len(old_x_vals) == 2: # With two points the only option is a straight segment k = 1 elif len(old_x_vals) == 3: # With three points we use an arc, using linear interpolation will result in invalid road tests k = 2 else: # Otheriwse, use cubic splines k = 3 pos_tck, pos_u = splprep([old_x_vals, old_y_vals], s=smoothness, k=k) step_size = 1 / num_nodes unew = arange(0, 1 + step_size, step_size) new_x_vals, new_y_vals = splev(unew, pos_tck) # Return the 4-tuple with default z and defatul road width return list( zip([round(v, rounding_precision) for v in new_x_vals], [round(v, rounding_precision) for v in new_y_vals], [-28.0 for v in new_x_vals], [8.0 for v in new_x_vals]))
def show(model, x_tr, x_te, y_tr, y_te, verb=0, plt=True, bs=200, eps=None, plt_title=None, num=None): acc = list() val_acc = list() test_acc = list() loss = list() epochs = 10 if not eps else eps best_scores = [-1, -1, -1, -1] best_epoch = None loss_now = 1000000 go = True for _ in range(epochs): history = model.fit(x_tr, y_tr, epochs=1, batch_size=bs, validation_split=0.05, verbose=verb) acc += history.history['accuracy'] val_acc += history.history['val_accuracy'] scores = model.evaluate(x_te, y_te, verbose=0) test_acc += [scores[3]] loss += history.history['val_loss'] if num is not None and _ % num == 0: f1_score = 2 * scores[1] * scores[2] / (scores[1] + scores[2]) if scores[1] + scores[2] != 0 else 0 print("Accuracy: {} F1 score: {} Loss: {}".format(scores[3], f1_score, scores[0])) if loss_now > history.history['val_loss'][0] and go: loss_now = history.history['val_loss'][0] if best_scores[3] < scores[3]: best_scores = scores best_epoch = _ + 1 else: go = False if plt: figure(figsize=(8, 5)) grid(True) xticks(arange(1, epochs + 1, 1)) yticks(arange(0, 1.05, 0.05)) plot_title(plt_title) plot(arange(1, epochs + 1, 1), acc, label='Learning') plot(arange(1, epochs + 1, 1), val_acc, label='Validation') plot(arange(1, epochs + 1, 1), test_acc, label='Test') plot(arange(1, epochs + 1, 1), loss, label='Validation loss') xlabel('Epoch') ylabel('Accuracy') legend() # plot_show() savefig("plots/" + plt_title + ".png") close("all") del model return best_scores, best_epoch
def newton_czybyszew(nodes_amount): gd = graph(title='Interpolacja Newtona\'a') f1 = gcurve(graph=gd, color=color.cyan) dots = gdots(graph=gd, color=color.red) f2 = gcurve(graph=gd, color=color.green) # wyliczanie wartości funkcji podstawowej w tym przypadku cos(2*x) * exp(-0.2 * x) field_end = 8.05 for x in arange(0, field_end, 0.1): y = origin_newton_function(x) f1.plot(x, y) # tablica do przechowywania wylosowanych punktów initial_points = [] for x in czybyszew_points(nodes_amount, 0, field_end): y = origin_newton_function(x) dots.plot(x, y) initial_points.append({'x': x, 'y': y}) # wyliczanie i rysowanie interpolacji for point in newton_interpolation(initial_points, field_end): f2.plot(point['x'], point['y'])
def test_testCopySize(self): # Tests of some subtle points of copying and sizing. n = [0, 0, 1, 0, 0] m = make_mask(n) m2 = make_mask(m) self.assertTrue(m is m2) m3 = make_mask(m, copy=1) self.assertTrue(m is not m3) x1 = np.arange(5) y1 = array(x1, mask=m) self.assertTrue(y1._data is not x1) self.assertTrue(allequal(x1, y1._data)) self.assertTrue(y1.mask is m) y1a = array(y1, copy=0) self.assertTrue(y1a.mask is y1.mask) y2 = array(x1, mask=m, copy=0) self.assertTrue(y2.mask is m) self.assertTrue(y2[2] is masked) y2[2] = 9 self.assertTrue(y2[2] is not masked) self.assertTrue(y2.mask is not m) self.assertTrue(allequal(y2.mask, 0)) y3 = array(x1 * 1.0, mask=m) self.assertTrue(filled(y3).dtype is (x1 * 1.0).dtype) x4 = arange(4) x4[2] = masked y4 = resize(x4, (8, )) self.assertTrue(eq(concatenate([x4, x4]), y4)) self.assertTrue(eq(getmask(y4), [0, 0, 1, 0, 0, 0, 1, 0])) y5 = repeat(x4, (2, 2, 2, 2), axis=0) self.assertTrue(eq(y5, [0, 0, 1, 1, 2, 2, 3, 3])) y6 = repeat(x4, 2, axis=0) self.assertTrue(eq(y5, y6))
def _interpolate_nodes( old_x_vals: List[float], old_y_vals: List[float], old_width_vals: List[float], num_nodes: int ) -> Tuple[List[float], List[float], List[float], List[float]]: assert len(old_x_vals) == len(old_y_vals) == len(old_width_vals), \ "The lists for the interpolation must have the same length." k = 1 if len(old_x_vals) <= 3 else 3 pos_tck, pos_u = splprep([old_x_vals, old_y_vals], s=self.add_roads_to_scenario.smoothness, k=k) step_size = 1 / num_nodes unew = arange(0, 1 + step_size, step_size) new_x_vals, new_y_vals = splev(unew, pos_tck) z_vals = repeat(0.01, len(unew)) width_tck, width_u = splprep( [pos_u, old_width_vals], s=self.add_roads_to_scenario.smoothness, k=k) _, new_width_vals = splev(unew, width_tck) # Reduce floating point rounding errors otherwise these may cause problems with calculating parallel_offset return [round(v, _interpolate_nodes.rounding_precision) for v in new_x_vals], \ [round(v, _interpolate_nodes.rounding_precision) for v in new_y_vals], \ z_vals, new_width_vals
def plotBestFit(w, b, dataMat, labelMat): m = dataMat.shape[0] xcord1 = [] ycord1 = [] xcord2 = [] ycord2 = [] for i in range(m): if int(labelMat[i]) == 1: xcord1.append(dataMat[i, 0]) ycord1.append(dataMat[i, 1]) else: xcord2.append(dataMat[i, 0]) ycord2.append(dataMat[i, 1]) fig = plt.figure() ax = fig.add_subplot(111) ax.scatter(xcord1, ycord1, s=30, c='red', marker='x') ax.scatter(xcord2, ycord2, s=30, c='green', marker='o') x = arange(-3.0, 3.0, 0.1) y = (-w[0] * x - b) / w[1] ax.plot(x, y) plt.xlabel('X') plt.ylabel('Y') plt.show()
def get_recall_data(statistics, available_classes, alg_name): x_complex = [] add_empty(x_complex, available_classes) for statistic in statistics: for index, clazz in enumerate(available_classes): for single_recall in statistic.class_recall: if single_recall.class_name == clazz: x_complex[index].is_nullable = False x_complex[index].items.append(single_recall.recall) for item in x_complex: if item.is_nullable: x_complex.remove(item) plt.figure(num=None, figsize=(14, 7), dpi=80, facecolor='w', edgecolor='k') plt.rcParams.update({'font.size': 20}) plt.subplot(111) x_range = list(arange(1, len(x_complex[0].items) + 1, 1.0)) x = np.array(x_range) plt.bar(x - 0.3, x_complex[0].items, width=0.6, fill=True, label=x_complex[0].class_name, align='center') plt.bar(x + 0.3, x_complex[1].items, width=0.6, fill=True, label=x_complex[1].class_name, align='center') plt.xlabel('Numer klatki', fontsize=20) plt.ylabel('Pokrycie', fontsize=20) plt.title('Pokrycie w poszczególnych klatkach - ' + alg_name, fontsize=20) plt.xticks(np.arange(0, len(x), 10)) # handles, labels = plt.get_legend_handles_labels() plt.legend(prop={'size': 20}) plt.show()
def gurwitz_crit(): w = initPamsLab2.calc_w() matrix = formating_matrix(w) print(matrix) for i in range(len(matrix), 0, -1): opr = det(matrix[:i, :i]) print("det of", i, "matrix: ", opr) if opr < 0: print("ne ust") break a = 0 inits = initPamsLab2.init_pams() for i in arange(1.3936, 1.3937, 0.00001): inits[1] = i w = initPamsLab2.finish_chain(inits) matrix = formating_matrix(w) opr = det(matrix[:len(matrix) - 1, :len(matrix) - 1]) print("det", opr, "Koc:", i) if - 2 <= opr <= 2 else "no" listA = [inits[1] - 5, inits[1], inits[1] + 5] for i in range(3): initis = initPamsLab2.init_pams() initis[1] = listA[i] print(initis[1]) w = initPamsLab2.finish_chain(initis) newToolBox.newToolBox.all_of_them(w) w1 = initPamsLab2.finish_for_nyquist(initis) NyquistBode.NyquistBode.all_of_them(w1)
def test_GridToMeshESMFRegridder_bilinear_round_trip(tmp_path): """Test save/load round tripping for `GridToMeshESMFRegridder`.""" original_rg, src = _make_grid_to_mesh_regridder(method="bilinear") filename = tmp_path / "regridder.nc" save_regridder(original_rg, filename) loaded_rg = load_regridder(str(filename)) assert original_rg.location == loaded_rg.location assert original_rg.method == loaded_rg.method assert original_rg.mdtol == loaded_rg.mdtol assert original_rg.grid_x == loaded_rg.grid_x assert original_rg.grid_y == loaded_rg.grid_y # TODO: uncomment when iris mesh comparison becomes available. # assert original_rg.mesh == loaded_rg.mesh # Compare the weight matrices. original_matrix = original_rg.regridder.weight_matrix loaded_matrix = loaded_rg.regridder.weight_matrix # Ensure the original and loaded weight matrix have identical type. assert type(original_matrix) is type(loaded_matrix) # noqa E721 assert np.array_equal(original_matrix.todense(), loaded_matrix.todense()) # Demonstrate regridding still gives the same results. src_data = ma.arange(np.product(src.data.shape)).reshape(src.data.shape) src_data[0, 0] = ma.masked src.data = src_data # TODO: make this a cube comparison when mesh comparison becomes available. original_result = original_rg(src).data loaded_result = loaded_rg(src).data assert np.array_equal(original_result, loaded_result) assert np.array_equal(original_result.mask, loaded_result.mask) # Ensure version data is equal. assert original_rg.regridder.esmf_version == loaded_rg.regridder.esmf_version assert (original_rg.regridder.esmf_regrid_version == loaded_rg.regridder.esmf_regrid_version)
def get_godoghraph(self): w_den = tf(self.w.den[0][0], [1]) print(w_den) array = [] x = [] y = [] j = sqrt(-1) length_of_array = 2 for q in arange(0, length_of_array, 0.01): array.append(w_den(q * j)) for i in array: x.append(re(i)) y.append(im(i)) plt.plot(x, y, "r") plt.title('Godograph') plt.ylabel('jY') plt.xlabel('X') plt.grid(True) plt.show()
def test_testPut(self): # Test of put with suppress_warnings() as sup: sup.filter( np.ma.core.MaskedArrayFutureWarning, "setting an item on a masked array which has a " "shared mask will not copy") d = arange(5) n = [0, 0, 0, 1, 1] m = make_mask(n) x = array(d, mask=m) self.assertTrue(x[3] is masked) self.assertTrue(x[4] is masked) x[[1, 4]] = [10, 40] self.assertTrue(x.mask is not m) self.assertTrue(x[3] is masked) self.assertTrue(x[4] is not masked) self.assertTrue(eq(x, [0, 10, 2, -1, 40])) x = array(d, mask=m) x.put([0, 1, 2], [-1, 100, 200]) self.assertTrue(eq(x, [-1, 100, 200, 0, 0])) self.assertTrue(x[3] is masked) self.assertTrue(x[4] is masked)
def test_trim(self): a = ma.arange(10) assert_equal(mstats.trim(a), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) a = ma.arange(10) assert_equal(mstats.trim(a, (2, 8)), [None, None, 2, 3, 4, 5, 6, 7, 8, None]) a = ma.arange(10) assert_equal(mstats.trim(a, limits=(2, 8), inclusive=(False, False)), [None, None, None, 3, 4, 5, 6, 7, None, None]) a = ma.arange(10) assert_equal(mstats.trim(a, limits=(0.1, 0.2), relative=True), [None, 1, 2, 3, 4, 5, 6, 7, None, None]) a = ma.arange(12) a[[0, -1]] = a[5] = masked assert_equal(mstats.trim(a, (2, 8)), [None, None, 2, 3, 4, None, 6, 7, 8, None, None, None]) x = ma.arange(100).reshape(10, 10) expected = [1] * 10 + [0] * 70 + [1] * 20 trimx = mstats.trim(x, (0.1, 0.2), relative=True, axis=None) assert_equal(trimx._mask.ravel(), expected) trimx = mstats.trim(x, (0.1, 0.2), relative=True, axis=0) assert_equal(trimx._mask.ravel(), expected) trimx = mstats.trim(x, (0.1, 0.2), relative=True, axis=-1) assert_equal(trimx._mask.T.ravel(), expected) # same as above, but with an extra masked row inserted x = ma.arange(110).reshape(11, 10) x[1] = masked expected = [1] * 20 + [0] * 70 + [1] * 20 trimx = mstats.trim(x, (0.1, 0.2), relative=True, axis=None) assert_equal(trimx._mask.ravel(), expected) trimx = mstats.trim(x, (0.1, 0.2), relative=True, axis=0) assert_equal(trimx._mask.ravel(), expected) trimx = mstats.trim(x.T, (0.1, 0.2), relative=True, axis=-1) assert_equal(trimx.T._mask.ravel(), expected)
import numpy.ma as ma a = ma.arange(6).reshape((2, 3)) a[1, :] = ma.masked a a.count() a.count(axis=0) a.count(axis=1)
def test_testOddFeatures(self): # Test of other odd features x = arange(20) x = x.reshape(4, 5) x.flat[5] = 12 assert_(x[1, 0] == 12) z = x + 10j * x assert_(eq(z.real, x)) assert_(eq(z.imag, 10 * x)) assert_(eq((z * conjugate(z)).real, 101 * x * x)) z.imag[...] = 0.0 x = arange(10) x[3] = masked assert_(str(x[3]) == str(masked)) c = x >= 8 assert_(count(where(c, masked, masked)) == 0) assert_(shape(where(c, masked, masked)) == c.shape) z = where(c, x, masked) assert_(z.dtype is x.dtype) assert_(z[3] is masked) assert_(z[4] is masked) assert_(z[7] is masked) assert_(z[8] is not masked) assert_(z[9] is not masked) assert_(eq(x, z)) z = where(c, masked, x) assert_(z.dtype is x.dtype) assert_(z[3] is masked) assert_(z[4] is not masked) assert_(z[7] is not masked) assert_(z[8] is masked) assert_(z[9] is masked) z = masked_where(c, x) assert_(z.dtype is x.dtype) assert_(z[3] is masked) assert_(z[4] is not masked) assert_(z[7] is not masked) assert_(z[8] is masked) assert_(z[9] is masked) assert_(eq(x, z)) x = array([1., 2., 3., 4., 5.]) c = array([1, 1, 1, 0, 0]) x[2] = masked z = where(c, x, -x) assert_(eq(z, [1., 2., 0., -4., -5])) c[0] = masked z = where(c, x, -x) assert_(eq(z, [1., 2., 0., -4., -5])) assert_(z[0] is masked) assert_(z[1] is not masked) assert_(z[2] is masked) assert_(eq(masked_where(greater(x, 2), x), masked_greater(x, 2))) assert_(eq(masked_where(greater_equal(x, 2), x), masked_greater_equal(x, 2))) assert_(eq(masked_where(less(x, 2), x), masked_less(x, 2))) assert_(eq(masked_where(less_equal(x, 2), x), masked_less_equal(x, 2))) assert_(eq(masked_where(not_equal(x, 2), x), masked_not_equal(x, 2))) assert_(eq(masked_where(equal(x, 2), x), masked_equal(x, 2))) assert_(eq(masked_where(not_equal(x, 2), x), masked_not_equal(x, 2))) assert_(eq(masked_inside(list(range(5)), 1, 3), [0, 199, 199, 199, 4])) assert_(eq(masked_outside(list(range(5)), 1, 3), [199, 1, 2, 3, 199])) assert_(eq(masked_inside(array(list(range(5)), mask=[1, 0, 0, 0, 0]), 1, 3).mask, [1, 1, 1, 1, 0])) assert_(eq(masked_outside(array(list(range(5)), mask=[0, 1, 0, 0, 0]), 1, 3).mask, [1, 1, 0, 0, 1])) assert_(eq(masked_equal(array(list(range(5)), mask=[1, 0, 0, 0, 0]), 2).mask, [1, 0, 1, 0, 0])) assert_(eq(masked_not_equal(array([2, 2, 1, 2, 1], mask=[1, 0, 0, 0, 0]), 2).mask, [1, 0, 1, 0, 1])) assert_(eq(masked_where([1, 1, 0, 0, 0], [1, 2, 3, 4, 5]), [99, 99, 3, 4, 5])) atest = ones((10, 10, 10), dtype=np.float32) btest = zeros(atest.shape, MaskType) ctest = masked_where(btest, atest) assert_(eq(atest, ctest)) z = choose(c, (-x, x)) assert_(eq(z, [1., 2., 0., -4., -5])) assert_(z[0] is masked) assert_(z[1] is not masked) assert_(z[2] is masked) x = arange(6) x[5] = masked y = arange(6) * 10 y[2] = masked c = array([1, 1, 1, 0, 0, 0], mask=[1, 0, 0, 0, 0, 0]) cm = c.filled(1) z = where(c, x, y) zm = where(cm, x, y) assert_(eq(z, zm)) assert_(getmask(zm) is nomask) assert_(eq(zm, [0, 1, 2, 30, 40, 50])) z = where(c, masked, 1) assert_(eq(z, [99, 99, 99, 1, 1, 1])) z = where(c, 1, masked) assert_(eq(z, [99, 1, 1, 99, 99, 99]))
def plot(self, **kwargs) -> Figure: """ Plot a grid of the different components of the Compound Distribution. :param kwargs: kwargs for plot methods """ ppf_prior_01 = self.prior().ppf().at(0.01) ppf_prior_99 = self.prior().ppf().at(0.99) ppf_posterior_01 = self.posterior().ppf().at(0.99) ppf_posterior_99 = self.posterior().ppf().at(0.99) x_norm_min = int(min(ppf_prior_01, ppf_posterior_01)) - 1 x_norm_max = int(max(ppf_prior_99, ppf_posterior_99)) + 1 x_param = arange(x_norm_min, x_norm_max + 0.001, 0.001) ff = FigureFormatter(n_rows=2, n_cols=3) (ax_prior, ax_data, ax_posterior, ax_prior_predictive, ax_likelihood, ax_posterior_predictive) = ff.axes.flat # plot prior and posterior parameters self.prior().plot(x=x_param, ax=ax_prior.axes, **kwargs) self.posterior().plot(x=x_param, ax=ax_posterior.axes, **kwargs) y_max_params = max(ax_prior.get_y_max(), ax_posterior.get_y_max()) ax_prior.set_y_lim(0, y_max_params) ax_posterior.set_y_lim(0, y_max_params) ax_prior.set_title_text('prior').add_legend() ax_posterior.set_title_text('posterior').add_legend() # plot prior and posterior predictives ppf_prior_pred_01 = self.prior_predictive().ppf().at(0.01) ppf_prior_pred_99 = self.prior_predictive().ppf().at(0.99) ppf_posterior_pred_01 = self.posterior_predictive().ppf().at(0.01) ppf_posterior_pred_99 = self.posterior_predictive().ppf().at(0.99) x_pred_min = int(min(ppf_prior_pred_01, ppf_posterior_pred_01)) - 1 x_pred_max = int(max(ppf_prior_pred_99, ppf_posterior_pred_99)) + 1 x_pred = arange(x_pred_min, x_pred_max + 0.001, 0.001) self.prior_predictive().plot(x=x_pred, kind='line', ax=ax_prior_predictive.axes, **kwargs) self.posterior_predictive().plot(x=x_pred, kind='line', ax=ax_posterior_predictive.axes, **kwargs) y_max_pred = max(ax_prior_predictive.get_y_max(), ax_posterior_predictive.get_y_max()) ax_prior_predictive.set_y_lim(0, y_max_pred) ax_posterior_predictive.set_y_lim(0, y_max_pred) ax_prior_predictive.set_title_text('prior predictive').add_legend() ax_posterior_predictive.set_title_text( 'posterior predictive').add_legend() # plot data observations = self.likelihood().rvs(num_samples=self._n) observations.plot.bar(ax=ax_data.axes, **kwargs) ax_data.set_text(title='data', x_label='i', y_label='$X_i$') y_abs_max = max([abs(y_lim) for y_lim in ax_data.get_y_lim()]) ax_data.set_y_lim(-y_abs_max, y_abs_max) # plot likelihood x_like_min = int(self.likelihood().ppf().at(0.01)) - 1 x_like_max = int(self.likelihood().ppf().at(0.99)) + 1 x_exponential = arange(x_like_min, x_like_max + 0.001, 0.001) self.likelihood().plot(x=x_exponential, ax=ax_likelihood.axes) ax_likelihood.set_title_text('likelihood') ax_likelihood.add_legend() return ff.figure
def test_testInplace(self): # Test of inplace operations and rich comparisons y = arange(10) x = arange(10) xm = arange(10) xm[2] = masked x += 1 assert_(eq(x, y + 1)) xm += 1 assert_(eq(x, y + 1)) x = arange(10) xm = arange(10) xm[2] = masked x -= 1 assert_(eq(x, y - 1)) xm -= 1 assert_(eq(xm, y - 1)) x = arange(10) * 1.0 xm = arange(10) * 1.0 xm[2] = masked x *= 2.0 assert_(eq(x, y * 2)) xm *= 2.0 assert_(eq(xm, y * 2)) x = arange(10) * 2 xm = arange(10) xm[2] = masked x //= 2 assert_(eq(x, y)) xm //= 2 assert_(eq(x, y)) x = arange(10) * 1.0 xm = arange(10) * 1.0 xm[2] = masked x /= 2.0 assert_(eq(x, y / 2.0)) xm /= arange(10) assert_(eq(xm, ones((10,)))) x = arange(10).astype(np.float32) xm = arange(10) xm[2] = masked x += 1. assert_(eq(x, y + 1.))
def test_multi(self): for dtype in [np.int, np.float]: data = ma.arange(12, dtype=dtype) data[::2] = ma.masked self._check(data.reshape(3, 4))
def test_flat(self): for dtype in [np.int]: data = ma.arange(12, dtype=dtype) data[::2] = ma.masked self._check(data)
def test_no_mask_multi(self): for dtype in [np.int, np.float]: data = ma.arange(12, dtype=dtype).reshape(3, 4) self._check(data)
def test_no_mask_flat(self): for dtype in [np.int, np.float]: data = ma.arange(12, dtype=dtype) self._check(data)
import numpy.ma as ma a = ma.arange(3) a[1] = ma.masked b = ma.arange(2, 5) a b ma.concatenate([a, b])