def test_missing_mandatory_kwargs(self): emsg = ("weighted_percentile aggregator requires " ".* keyword argument 'percent'") with self.assertRaisesRegex(ValueError, emsg): WPERCENTILE.aggregate("dummy", axis=0, weights=None) emsg = ("weighted_percentile aggregator requires " ".* keyword argument 'weights'") with self.assertRaisesRegex(ValueError, emsg): WPERCENTILE.aggregate("dummy", axis=0, percent=50)
def test_missing_mandatory_kwargs(self): emsg = "weighted_percentile aggregator requires " \ ".* keyword argument 'percent'" with self.assertRaisesRegexp(ValueError, emsg): WPERCENTILE.aggregate('dummy', axis=0, weights=None) emsg = "weighted_percentile aggregator requires " \ ".* keyword argument 'weights'" with self.assertRaisesRegexp(ValueError, emsg): WPERCENTILE.aggregate('dummy', axis=0, percent=50)
def test_1d_single(self): data = np.arange(11) weights = np.ones(data.shape) actual = WPERCENTILE.aggregate(data, axis=0, percent=50, weights=weights) expected = 5 self.assertTupleEqual(actual.shape, ()) self.assertEqual(actual, expected)
def test_1d_multi(self): data = np.arange(11) weights = np.ones(data.shape) percent = np.array([20, 50, 90]) actual = WPERCENTILE.aggregate(data, axis=0, percent=percent, weights=weights) expected = [1.7, 5, 9.4] self.assertTupleEqual(actual.shape, percent.shape) self.assertArrayAlmostEqual(actual, expected)
def test_2d_single(self): shape = (2, 11) data = np.arange(np.prod(shape)).reshape(shape) weights = np.ones(shape) actual = WPERCENTILE.aggregate(data, axis=0, percent=50, weights=weights) self.assertTupleEqual(actual.shape, shape[-1:]) expected = np.arange(shape[-1]) + 5.5 self.assertArrayEqual(actual, expected)
def test_1d_single_unequal(self): data = np.arange(12) weights = np.ones(data.shape) weights[0:3] = 3 actual, weight_total = WPERCENTILE.aggregate( data, axis=0, percent=50, weights=weights, returned=True) expected = 2.75 self.assertTupleEqual(actual.shape, ()) self.assertEqual(actual, expected) self.assertEqual(weight_total, 18)
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_1d_multi_unequal(self): data = np.arange(13) weights = np.ones(data.shape) weights[1::2] = 3 percent = np.array([20, 50, 96]) actual = WPERCENTILE.aggregate(data, axis=0, percent=percent, weights=weights) expected = [2.25, 6, 11.75] self.assertTupleEqual(actual.shape, percent.shape) self.assertArrayAlmostEqual(actual, expected)
def test_2d_multi(self): shape = (2, 10) data = np.arange(np.prod(shape)).reshape(shape) weights = np.ones(shape) percent = np.array([10, 50, 70, 100]) actual = WPERCENTILE.aggregate(data, axis=0, percent=percent, weights=weights) 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:-1] += (percent[1:-1]-25)*0.2 expected[:, -1] += 10. self.assertArrayAlmostEqual(actual, expected)
def test_1d_single_unequal(self): data = np.arange(12) weights = np.ones(data.shape) weights[0:3] = 3 actual, weight_total = WPERCENTILE.aggregate(data, axis=0, percent=50, weights=weights, returned=True) expected = 2.75 self.assertTupleEqual(actual.shape, ()) self.assertEqual(actual, expected) self.assertEqual(weight_total, 18)
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 weights = np.ones(shape) actual = WPERCENTILE.aggregate(data, axis=0, percent=50, weights=weights) 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_2d_multi(self): shape = (2, 10) data = np.arange(np.prod(shape)).reshape(shape) weights = np.ones(shape) percent = np.array([10, 50, 70, 100]) actual = WPERCENTILE.aggregate(data, axis=0, percent=percent, weights=weights) self.assertTupleEqual(actual.shape, (shape[-1], percent.size)) expected = np.tile(np.arange(shape[-1]), percent.size).astype("f8") expected = expected.reshape(percent.size, shape[-1]).T expected[:, 1:-1] += (percent[1:-1] - 25) * 0.2 expected[:, -1] += 10.0 self.assertArrayAlmostEqual(actual, expected)
def test_masked_2d_multi(self): shape = (3, 10) data = ma.arange(np.prod(shape)).reshape(shape) weights = np.ones(shape) data[1] = ma.masked percent = np.array([10, 50, 70, 80]) actual = WPERCENTILE.aggregate(data, axis=0, percent=percent, weights=weights) 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:-1] += (percent[1:-1] - 25) * 0.4 expected[:, -1] += 20. self.assertArrayAlmostEqual(actual, expected)
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_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_mandatory_kwarg_no_shape(self): kwargs = dict(percent=50, weights=None) self.assertTupleEqual(WPERCENTILE.aggregate_shape(**kwargs), ()) kwargs = dict(percent=[50], weights=None) self.assertTupleEqual(WPERCENTILE.aggregate_shape(**kwargs), ())
def test_missing_mandatory_kwarg(self): emsg_pc = "weighted_percentile aggregator requires " \ ".* keyword argument 'percent'" emsg_wt = "weighted_percentile aggregator requires " \ ".* keyword argument 'weights'" with self.assertRaisesRegexp(ValueError, emsg_pc): WPERCENTILE.aggregate_shape(weights=None) with self.assertRaisesRegexp(ValueError, emsg_pc): kwargs = dict(weights=None) WPERCENTILE.aggregate_shape(**kwargs) with self.assertRaisesRegexp(ValueError, emsg_pc): kwargs = dict(point=10) WPERCENTILE.aggregate_shape(**kwargs) with self.assertRaisesRegexp(ValueError, emsg_wt): WPERCENTILE.aggregate_shape(percent=50) with self.assertRaisesRegexp(ValueError, emsg_wt): kwargs = dict(percent=50) WPERCENTILE.aggregate_shape(**kwargs) with self.assertRaisesRegexp(ValueError, emsg_wt): kwargs = dict(percent=50, weight=None) WPERCENTILE.aggregate_shape(**kwargs)
def test_wrong_weights_shape(self): data = np.arange(11) weights = np.ones(10) emsg = "_weighted_percentile: weights wrong shape." with self.assertRaisesRegex(ValueError, emsg): WPERCENTILE.aggregate(data, axis=0, percent=50, weights=weights)
def test_mandatory_kwarg_shape(self): kwargs = dict(percent=(10, 20), weights=None) self.assertTupleEqual(WPERCENTILE.aggregate_shape(**kwargs), (2, )) kwargs = dict(percent=range(13), weights=None) self.assertTupleEqual(WPERCENTILE.aggregate_shape(**kwargs), (13, ))
def test_missing_mandatory_kwarg(self): emsg_pc = ("weighted_percentile aggregator requires " ".* keyword argument 'percent'") emsg_wt = ("weighted_percentile aggregator requires " ".* keyword argument 'weights'") with self.assertRaisesRegex(ValueError, emsg_pc): WPERCENTILE.aggregate_shape(weights=None) with self.assertRaisesRegex(ValueError, emsg_pc): kwargs = dict(weights=None) WPERCENTILE.aggregate_shape(**kwargs) with self.assertRaisesRegex(ValueError, emsg_pc): kwargs = dict(point=10) WPERCENTILE.aggregate_shape(**kwargs) with self.assertRaisesRegex(ValueError, emsg_wt): WPERCENTILE.aggregate_shape(percent=50) with self.assertRaisesRegex(ValueError, emsg_wt): kwargs = dict(percent=50) WPERCENTILE.aggregate_shape(**kwargs) with self.assertRaisesRegex(ValueError, emsg_wt): kwargs = dict(percent=50, weight=None) WPERCENTILE.aggregate_shape(**kwargs)
def test_mandatory_kwarg_shape(self): kwargs = dict(percent=(10, 20), weights=None) self.assertTupleEqual(WPERCENTILE.aggregate_shape(**kwargs), (2,)) kwargs = dict(percent=range(13), weights=None) self.assertTupleEqual(WPERCENTILE.aggregate_shape(**kwargs), (13,))
def test(self): self.assertEqual(WPERCENTILE.name(), 'weighted_percentile')
def test(self): self.assertEqual(WPERCENTILE.name(), "weighted_percentile")
def test_wrong_weights_shape(self): data = np.arange(11) weights = np.ones(10) emsg = "_weighted_percentile: weights wrong shape." with self.assertRaisesRegexp(ValueError, emsg): WPERCENTILE.aggregate(data, axis=0, percent=50, weights=weights)