class TestOneDSlicerIteration(unittest.TestCase): def setUp(self): self.testslicer = OneDSlicer(sliceColName='testdata') dvmin = 0 dvmax = 1 nvalues = 1000 self.bins = np.arange(dvmin, dvmax, 0.01) dv = makeDataValues(nvalues, dvmin, dvmax, random=5678) self.testslicer = OneDSlicer(sliceColName='testdata', bins=self.bins) self.testslicer.setupSlicer(dv) def tearDown(self): del self.testslicer self.testslicer = None def testIteration(self): """Test iteration.""" for i, (s, b) in enumerate(zip(self.testslicer, self.bins)): self.assertEqual(s['slicePoint']['sid'], i) self.assertEqual(s['slicePoint']['binLeft'], b) def testGetItem(self): """Test that can return an individual indexed values of the slicer.""" for i in ([0, 10, 20]): self.assertEqual(self.testslicer[i]['slicePoint']['sid'], i) self.assertEqual(self.testslicer[i]['slicePoint']['binLeft'], self.bins[i])
def testSlicing(self): """Test slicing.""" dvmin = 0 dvmax = 1 nbins = 100 # Test that testbinner raises appropriate error before it's set up (first time) self.assertRaises(NotImplementedError, self.testslicer._sliceSimData, 0) for nvalues in (1000, 10000, 100000): dv = makeDataValues(nvalues, dvmin, dvmax, random=560) self.testslicer = OneDSlicer(sliceColName='testdata', bins=nbins) self.testslicer.setupSlicer(dv) sum = 0 for i, s in enumerate(self.testslicer): idxs = s['idxs'] dataslice = dv['testdata'][idxs] sum += len(idxs) if len(dataslice) > 0: self.assertEqual(len(dataslice), nvalues / float(nbins)) else: self.assertGreater( len(dataslice), 0, msg= 'Data in test case expected to always be > 0 len after slicing' ) self.assertTrue(sum, nvalues)
class TestOneDSlicerSlicing(unittest.TestCase): def setUp(self): self.testslicer = OneDSlicer(sliceColName='testdata') def tearDown(self): del self.testslicer self.testslicer = None def testSlicing(self): """Test slicing.""" dvmin = 0 dvmax = 1 nbins = 100 binsize = (dvmax - dvmin) / (float(nbins)) # Test that testbinner raises appropriate error before it's set up (first time) self.assertRaises(NotImplementedError, self.testslicer._sliceSimData, 0) for nvalues in (1000, 10000, 100000): dv = makeDataValues(nvalues, dvmin, dvmax, random=True) self.testslicer = OneDSlicer(sliceColName='testdata', bins=nbins) self.testslicer.setupSlicer(dv) sum = 0 for i, s in enumerate(self.testslicer): idxs = s['idxs'] dataslice = dv['testdata'][idxs] sum += len(idxs) if len(dataslice)>0: self.assertTrue(len(dataslice), nvalues/float(nbins)) else: self.assertTrue(len(dataslice) > 0, 'Data in test case expected to always be > 0 len after slicing') self.assertTrue(sum, nvalues)
class TestOneDSlicerIteration(unittest.TestCase): def setUp(self): self.testslicer = OneDSlicer(sliceColName='testdata') dvmin = 0 dvmax = 1 nvalues = 1000 self.bins = np.arange(dvmin, dvmax, 0.01) dv = makeDataValues(nvalues, dvmin, dvmax, random=True) self.testslicer = OneDSlicer(sliceColName='testdata',bins=self.bins) self.testslicer.setupSlicer(dv) def tearDown(self): del self.testslicer self.testslicer = None def testIteration(self): """Test iteration.""" for i,(s, b) in enumerate(zip(self.testslicer, self.bins)): self.assertEqual(s['slicePoint']['sid'], i) self.assertEqual(s['slicePoint']['binLeft'], b) def testGetItem(self): """Test that can return an individual indexed values of the slicer.""" for i in ([0, 10, 20]): self.assertEqual(self.testslicer[i]['slicePoint']['sid'], i) self.assertEqual(self.testslicer[i]['slicePoint']['binLeft'], self.bins[i])
class TestOneDSlicerSlicing(unittest.TestCase): def setUp(self): self.testslicer = OneDSlicer(sliceColName='testdata') def tearDown(self): del self.testslicer self.testslicer = None def testSlicing(self): """Test slicing.""" dvmin = 0 dvmax = 1 nbins = 100 binsize = (dvmax - dvmin) / (float(nbins)) # Test that testbinner raises appropriate error before it's set up (first time) self.assertRaises(NotImplementedError, self.testslicer._sliceSimData, 0) for nvalues in (1000, 10000, 100000): dv = makeDataValues(nvalues, dvmin, dvmax, random=True) self.testslicer = OneDSlicer(sliceColName='testdata', bins=nbins) self.testslicer.setupSlicer(dv) sum = 0 for i, s in enumerate(self.testslicer): idxs = s['idxs'] dataslice = dv['testdata'][idxs] sum += len(idxs) if len(dataslice) > 0: self.assertTrue(len(dataslice), nvalues / float(nbins)) else: self.assertTrue( len(dataslice) > 0, 'Data in test case expected to always be > 0 len after slicing' ) self.assertTrue(sum, nvalues)
def setUp(self): self.testslicer = OneDSlicer(sliceColName='testdata') dvmin = 0 dvmax = 1 nvalues = 1000 self.bins = np.arange(dvmin, dvmax, 0.01) dv = makeDataValues(nvalues, dvmin, dvmax, random=5678) self.testslicer = OneDSlicer(sliceColName='testdata', bins=self.bins) self.testslicer.setupSlicer(dv)
class TestOneDSlicerEqual(unittest.TestCase): def setUp(self): self.testslicer = OneDSlicer(sliceColName='testdata') def tearDown(self): del self.testslicer self.testslicer = None def testEquivalence(self): """Test equals method.""" # Note that two OneD slicers will be considered equal if they are both the same kind of # slicer AND have the same bins. # Set up self.. dvmin = 0 dvmax = 1 nvalues = 1000 bins = np.arange(dvmin, dvmax, 0.01) dv = makeDataValues(nvalues, dvmin, dvmax, random=True) self.testslicer = OneDSlicer(sliceColName='testdata', bins=bins) self.testslicer.setupSlicer(dv) # Set up another slicer to match (same bins, although not the same data). dv2 = makeDataValues(nvalues+100, dvmin, dvmax, random=True) testslicer2 = OneDSlicer(sliceColName='testdata', bins=bins) testslicer2.setupSlicer(dv2) self.assertTrue(self.testslicer == testslicer2) self.assertFalse(self.testslicer != testslicer2) # Set up another slicer that should not match (different bins) dv2 = makeDataValues(nvalues, dvmin+1, dvmax+1, random=True) testslicer2 = OneDSlicer(sliceColName='testdata', bins=len(bins)) testslicer2.setupSlicer(dv2) self.assertTrue(self.testslicer != testslicer2) self.assertFalse(self.testslicer == testslicer2) # Set up a different kind of slicer that should not match. dv2 = makeDataValues(100, 0, 1, random=True) testslicer2 = UniSlicer() testslicer2.setupSlicer(dv2) self.assertTrue(self.testslicer != testslicer2) self.assertFalse(self.testslicer == testslicer2) # Get another oneDslicer that is not set up, and check equivalence. testslicer2 = OneDSlicer(sliceColName='testdata') self.assertTrue(self.testslicer != testslicer2) self.assertFalse(self.testslicer == testslicer2) testslicer2 = OneDSlicer(sliceColName='testdata', binMin=0, binMax=1, binsize=0.5) testslicer3 = OneDSlicer(sliceColName='testdata', binMin=0, binMax=1, binsize=0.5) self.assertTrue(testslicer2 == testslicer3) self.assertFalse(testslicer2 != testslicer3) testslicer3 = OneDSlicer(sliceColName='testdata', binMin=0, binMax=1) self.assertFalse(testslicer2 == testslicer3) self.assertTrue(testslicer2 != testslicer3) usebins = np.arange(0, 1, 0.1) testslicer2 = OneDSlicer(sliceColName='testdata', bins=usebins) testslicer3 = OneDSlicer(sliceColName='testdata', bins=usebins) self.assertTrue(testslicer2 == testslicer3) self.assertFalse(testslicer2 != testslicer3) testslicer3 = OneDSlicer(sliceColName='testdata', bins=usebins+1) self.assertFalse(testslicer2 == testslicer3) self.assertTrue(testslicer2 != testslicer3)
def setUp(self): self.testslicer = OneDSlicer(sliceColName='testdata') dvmin = 0 dvmax = 1 nvalues = 1000 self.bins = np.arange(dvmin, dvmax, 0.01) dv = makeDataValues(nvalues, dvmin, dvmax, random=True) self.testslicer = OneDSlicer(sliceColName='testdata',bins=self.bins) self.testslicer.setupSlicer(dv)
def testSetupSlicerNbinsZeros(self): """Test what happens if give slicer test data that is all single-value.""" dv = np.zeros(100, float) dv = np.array(list(zip(dv)), dtype=[('testdata', 'float')]) nbins = 10 self.testslicer = OneDSlicer(sliceColName='testdata', bins=nbins) with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") self.testslicer.setupSlicer(dv) self.assertIn("creasing binMax", str(w[-1].message)) self.assertEqual(self.testslicer.nslice, nbins)
def testSetupSlicerFreedman(self): """Test that setting up the slicer using bins=None works.""" dvmin = 0 dvmax = 1 dv = makeDataValues(1000, dvmin, dvmax, random=2234) self.testslicer = OneDSlicer(sliceColName='testdata', bins=None) self.testslicer.setupSlicer(dv) # How many bins do you expect from optimal binsize? from lsst.sims.maf.utils import optimalBins bins = optimalBins(dv['testdata']) np.testing.assert_equal(self.testslicer.nslice, bins)
def testSetupSlicerBins(self): """Test setting up slicer using defined bins.""" dvmin = 0 dvmax = 1 nvalues = 1000 bins = np.arange(dvmin, dvmax, 0.1) dv = makeDataValues(nvalues, dvmin, dvmax, random=4) # Used right bins? self.testslicer = OneDSlicer(sliceColName='testdata', bins=bins) self.testslicer.setupSlicer(dv) np.testing.assert_equal(self.testslicer.bins, bins) self.assertEqual(self.testslicer.nslice, len(bins) - 1)
def testSetupSlicerEquivalent(self): """Test setting up slicer using defined bins and nbins is equal where expected.""" dvmin = 0 dvmax = 1 for nbins in (20, 50, 100, 105): bins = makeDataValues(nbins + 1, dvmin, dvmax, random=-1) bins = bins['testdata'] for nvalues in (100, 1000, 10000): dv = makeDataValues(nvalues, dvmin, dvmax, random=11) self.testslicer = OneDSlicer(sliceColName='testdata', bins=bins) self.testslicer.setupSlicer(dv) np.testing.assert_allclose(self.testslicer.bins, bins)
def testSetupSlicerLimits(self): """Test setting up slicer using binMin/Max.""" binMin = 0 binMax = 1 nbins = 10 dvmin = -.5 dvmax = 1.5 dv = makeDataValues(1000, dvmin, dvmax, random=342) self.testslicer = OneDSlicer(sliceColName='testdata', binMin=binMin, binMax=binMax, bins=nbins) self.testslicer.setupSlicer(dv) self.assertAlmostEqual(self.testslicer.bins.min(), binMin) self.assertAlmostEqual(self.testslicer.bins.max(), binMax)
def testSetupSlicerNbins(self): """Test setting up slicer using bins as integer.""" for nvalues in (100, 1000, 10000): for nbins in (5, 25, 75): dvmin = 0 dvmax = 1 dv = makeDataValues(nvalues, dvmin, dvmax, random=-1) # Right number of bins? # expect two more 'bins' to accomodate padding on left/right self.testslicer = OneDSlicer(sliceColName='testdata', bins=nbins) self.testslicer.setupSlicer(dv) self.assertEqual(self.testslicer.nslice, nbins) # Bins of the right size? bindiff = np.diff(self.testslicer.bins) expectedbindiff = (dvmax - dvmin) / float(nbins) np.testing.assert_allclose(bindiff, expectedbindiff)
def testSetupSlicerBinsize(self): """Test setting up slicer using binsize.""" dvmin = 0 dvmax = 1 dv = makeDataValues(1000, dvmin, dvmax, random=True) # Test basic use. binsize=0.5 self.testslicer = OneDSlicer(sliceColName='testdata', binsize=binsize) self.testslicer.setupSlicer(dv) # When binsize is specified, oneDslicer adds an extra bin to first/last spots. self.assertEqual(self.testslicer.nslice, (dvmax-dvmin)/binsize+2) # Test that warning works. with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") self.testslicer = OneDSlicer(sliceColName='testdata',bins=200,binsize=binsize) self.testslicer.setupSlicer(dv) # Verify some things self.assertTrue("binsize" in str(w[-1].message))
def testSetupSlicerNbinsZeros(self): """Test what happens if give slicer test data that is all single-value.""" dv = np.zeros(100, float) dv = np.array(zip(dv), dtype=[('testdata', 'float')]) nbins = 10 self.testslicer = OneDSlicer(sliceColName='testdata', bins=nbins) with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") self.testslicer.setupSlicer(dv) self.assertTrue("creasing binMax" in str(w[-1].message)) self.assertEqual(self.testslicer.nslice, nbins)
def testSetupSlicerBinsize(self): """Test setting up slicer using binsize.""" dvmin = 0 dvmax = 1 dv = makeDataValues(1000, dvmin, dvmax, random=8977) # Test basic use. binsize = 0.5 self.testslicer = OneDSlicer(sliceColName='testdata', binsize=binsize) self.testslicer.setupSlicer(dv) # When binsize is specified, oneDslicer adds an extra bin to first/last spots. self.assertEqual(self.testslicer.nslice, (dvmax - dvmin) / binsize + 2) # Test that warning works. with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") self.testslicer = OneDSlicer(sliceColName='testdata', bins=200, binsize=binsize) self.testslicer.setupSlicer(dv) # Verify some things self.assertIn("binsize", str(w[-1].message))
def testSetupSlicerFreedman(self): """Test that setting up the slicer using bins=None works.""" dvmin = 0 dvmax = 1 dv = makeDataValues(1000, dvmin, dvmax, random=True) self.testslicer = OneDSlicer(sliceColName='testdata', bins=None) self.testslicer.setupSlicer(dv) # How many bins do you expect from optimal binsize? from lsst.sims.maf.utils import optimalBins bins = optimalBins(dv['testdata']) np.testing.assert_equal(self.testslicer.nslice, bins)
def testSetupSlicerBins(self): """Test setting up slicer using defined bins.""" dvmin = 0 dvmax = 1 nvalues = 1000 bins = np.arange(dvmin, dvmax, 0.1) dv = makeDataValues(nvalues, dvmin, dvmax, random=True) # Used right bins? self.testslicer = OneDSlicer(sliceColName='testdata', bins=bins) self.testslicer.setupSlicer(dv) np.testing.assert_equal(self.testslicer.bins, bins) self.assertEqual(self.testslicer.nslice, len(bins)-1)
def testSetupSlicerEquivalent(self): """Test setting up slicer using defined bins and nbins is equal where expected.""" dvmin = 0 dvmax = 1 for nbins in (20, 50, 100, 105): bins = makeDataValues(nbins+1, dvmin, dvmax, random=False) bins = bins['testdata'] for nvalues in (100, 1000, 10000): dv = makeDataValues(nvalues, dvmin, dvmax, random=True) self.testslicer = OneDSlicer(sliceColName='testdata', bins=bins) self.testslicer.setupSlicer(dv) np.testing.assert_allclose(self.testslicer.bins, bins)
def testSetupSlicerLimits(self): """Test setting up slicer using binMin/Max.""" binMin = 0 binMax = 1 nbins = 10 dvmin = -.5 dvmax = 1.5 dv = makeDataValues(1000, dvmin, dvmax, random=True) self.testslicer = OneDSlicer(sliceColName='testdata', binMin=binMin, binMax=binMax, bins=nbins) self.testslicer.setupSlicer(dv) self.assertAlmostEqual(self.testslicer.bins.min(), binMin) self.assertAlmostEqual(self.testslicer.bins.max(), binMax)
def testEquivalence(self): """Test equals method.""" # Note that two uni slicers will be considered equal if they are both the same kind of # slicer (unislicer). They will not necessarily slice data equally though (the indices are # not necessarily the same!). # These should be the same, even though data is not the same. testslicer2 = UniSlicer() dv2 = makeDataValues(100, 0, 1, random=43298) testslicer2.setupSlicer(dv2) self.assertEqual(self.testslicer, testslicer2) # these will not be the same, as different slicer type. testslicer2 = OneDSlicer(sliceColName='testdata', bins=10) testslicer2.setupSlicer(dv2) self.assertNotEqual(self.testslicer, testslicer2)
def testSetupSlicerNbins(self): """Test setting up slicer using bins as integer.""" for nvalues in (100, 1000, 10000): for nbins in (5, 25, 75): dvmin = 0 dvmax = 1 dv = makeDataValues(nvalues, dvmin, dvmax, random=False) # Right number of bins? # expect two more 'bins' to accomodate padding on left/right self.testslicer = OneDSlicer(sliceColName='testdata', bins=nbins) self.testslicer.setupSlicer(dv) self.assertEqual(self.testslicer.nslice, nbins) # Bins of the right size? bindiff = np.diff(self.testslicer.bins) expectedbindiff = (dvmax - dvmin) / float(nbins) np.testing.assert_allclose(bindiff, expectedbindiff)
class TestOneDSlicerSetup(unittest.TestCase): def setUp(self): self.testslicer = OneDSlicer(sliceColName='testdata') def tearDown(self): del self.testslicer self.testslicer = None def testSlicertype(self): """Test instantiation of slicer sets slicer type as expected.""" self.assertEqual(self.testslicer.slicerName, self.testslicer.__class__.__name__) self.assertEqual(self.testslicer.slicerName, 'OneDSlicer') def testSetupSlicerBins(self): """Test setting up slicer using defined bins.""" dvmin = 0 dvmax = 1 nvalues = 1000 bins = np.arange(dvmin, dvmax, 0.1) dv = makeDataValues(nvalues, dvmin, dvmax, random=True) # Used right bins? self.testslicer = OneDSlicer(sliceColName='testdata', bins=bins) self.testslicer.setupSlicer(dv) np.testing.assert_equal(self.testslicer.bins, bins) self.assertEqual(self.testslicer.nslice, len(bins)-1) def testSetupSlicerNbins(self): """Test setting up slicer using bins as integer.""" for nvalues in (100, 1000, 10000): for nbins in (5, 25, 75): dvmin = 0 dvmax = 1 dv = makeDataValues(nvalues, dvmin, dvmax, random=False) # Right number of bins? # expect two more 'bins' to accomodate padding on left/right self.testslicer = OneDSlicer(sliceColName='testdata', bins=nbins) self.testslicer.setupSlicer(dv) self.assertEqual(self.testslicer.nslice, nbins) # Bins of the right size? bindiff = np.diff(self.testslicer.bins) expectedbindiff = (dvmax - dvmin) / float(nbins) np.testing.assert_allclose(bindiff, expectedbindiff) def testSetupSlicerNbinsZeros(self): """Test what happens if give slicer test data that is all single-value.""" dv = np.zeros(100, float) dv = np.array(zip(dv), dtype=[('testdata', 'float')]) nbins = 10 self.testslicer = OneDSlicer(sliceColName='testdata', bins=nbins) with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") self.testslicer.setupSlicer(dv) self.assertTrue("creasing binMax" in str(w[-1].message)) self.assertEqual(self.testslicer.nslice, nbins) def testSetupSlicerEquivalent(self): """Test setting up slicer using defined bins and nbins is equal where expected.""" dvmin = 0 dvmax = 1 for nbins in (20, 50, 100, 105): bins = makeDataValues(nbins+1, dvmin, dvmax, random=False) bins = bins['testdata'] for nvalues in (100, 1000, 10000): dv = makeDataValues(nvalues, dvmin, dvmax, random=True) self.testslicer = OneDSlicer(sliceColName='testdata', bins=bins) self.testslicer.setupSlicer(dv) np.testing.assert_allclose(self.testslicer.bins, bins) def testSetupSlicerLimits(self): """Test setting up slicer using binMin/Max.""" binMin = 0 binMax = 1 nbins = 10 dvmin = -.5 dvmax = 1.5 dv = makeDataValues(1000, dvmin, dvmax, random=True) self.testslicer = OneDSlicer(sliceColName='testdata', binMin=binMin, binMax=binMax, bins=nbins) self.testslicer.setupSlicer(dv) self.assertAlmostEqual(self.testslicer.bins.min(), binMin) self.assertAlmostEqual(self.testslicer.bins.max(), binMax) def testSetupSlicerBinsize(self): """Test setting up slicer using binsize.""" dvmin = 0 dvmax = 1 dv = makeDataValues(1000, dvmin, dvmax, random=True) # Test basic use. binsize=0.5 self.testslicer = OneDSlicer(sliceColName='testdata', binsize=binsize) self.testslicer.setupSlicer(dv) # When binsize is specified, oneDslicer adds an extra bin to first/last spots. self.assertEqual(self.testslicer.nslice, (dvmax-dvmin)/binsize+2) # Test that warning works. with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") self.testslicer = OneDSlicer(sliceColName='testdata',bins=200,binsize=binsize) self.testslicer.setupSlicer(dv) # Verify some things self.assertTrue("binsize" in str(w[-1].message)) def testSetupSlicerFreedman(self): """Test that setting up the slicer using bins=None works.""" dvmin = 0 dvmax = 1 dv = makeDataValues(1000, dvmin, dvmax, random=True) self.testslicer = OneDSlicer(sliceColName='testdata', bins=None) self.testslicer.setupSlicer(dv) # How many bins do you expect from optimal binsize? from lsst.sims.maf.utils import optimalBins bins = optimalBins(dv['testdata']) np.testing.assert_equal(self.testslicer.nslice, bins)
def setUp(self): self.testslicer = OneDSlicer(sliceColName='testdata')
class TestOneDSlicerSetup(unittest.TestCase): def setUp(self): self.testslicer = OneDSlicer(sliceColName='testdata') def tearDown(self): del self.testslicer self.testslicer = None def testSlicertype(self): """Test instantiation of slicer sets slicer type as expected.""" self.assertEqual(self.testslicer.slicerName, self.testslicer.__class__.__name__) self.assertEqual(self.testslicer.slicerName, 'OneDSlicer') def testSetupSlicerBins(self): """Test setting up slicer using defined bins.""" dvmin = 0 dvmax = 1 nvalues = 1000 bins = np.arange(dvmin, dvmax, 0.1) dv = makeDataValues(nvalues, dvmin, dvmax, random=4) # Used right bins? self.testslicer = OneDSlicer(sliceColName='testdata', bins=bins) self.testslicer.setupSlicer(dv) np.testing.assert_equal(self.testslicer.bins, bins) self.assertEqual(self.testslicer.nslice, len(bins) - 1) def testSetupSlicerNbins(self): """Test setting up slicer using bins as integer.""" for nvalues in (100, 1000, 10000): for nbins in (5, 25, 75): dvmin = 0 dvmax = 1 dv = makeDataValues(nvalues, dvmin, dvmax, random=-1) # Right number of bins? # expect two more 'bins' to accomodate padding on left/right self.testslicer = OneDSlicer(sliceColName='testdata', bins=nbins) self.testslicer.setupSlicer(dv) self.assertEqual(self.testslicer.nslice, nbins) # Bins of the right size? bindiff = np.diff(self.testslicer.bins) expectedbindiff = (dvmax - dvmin) / float(nbins) np.testing.assert_allclose(bindiff, expectedbindiff) def testSetupSlicerNbinsZeros(self): """Test what happens if give slicer test data that is all single-value.""" dv = np.zeros(100, float) dv = np.array(list(zip(dv)), dtype=[('testdata', 'float')]) nbins = 10 self.testslicer = OneDSlicer(sliceColName='testdata', bins=nbins) with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") self.testslicer.setupSlicer(dv) self.assertIn("creasing binMax", str(w[-1].message)) self.assertEqual(self.testslicer.nslice, nbins) def testSetupSlicerEquivalent(self): """Test setting up slicer using defined bins and nbins is equal where expected.""" dvmin = 0 dvmax = 1 for nbins in (20, 50, 100, 105): bins = makeDataValues(nbins + 1, dvmin, dvmax, random=-1) bins = bins['testdata'] for nvalues in (100, 1000, 10000): dv = makeDataValues(nvalues, dvmin, dvmax, random=11) self.testslicer = OneDSlicer(sliceColName='testdata', bins=bins) self.testslicer.setupSlicer(dv) np.testing.assert_allclose(self.testslicer.bins, bins) def testSetupSlicerLimits(self): """Test setting up slicer using binMin/Max.""" binMin = 0 binMax = 1 nbins = 10 dvmin = -.5 dvmax = 1.5 dv = makeDataValues(1000, dvmin, dvmax, random=342) self.testslicer = OneDSlicer(sliceColName='testdata', binMin=binMin, binMax=binMax, bins=nbins) self.testslicer.setupSlicer(dv) self.assertAlmostEqual(self.testslicer.bins.min(), binMin) self.assertAlmostEqual(self.testslicer.bins.max(), binMax) def testSetupSlicerBinsize(self): """Test setting up slicer using binsize.""" dvmin = 0 dvmax = 1 dv = makeDataValues(1000, dvmin, dvmax, random=8977) # Test basic use. binsize = 0.5 self.testslicer = OneDSlicer(sliceColName='testdata', binsize=binsize) self.testslicer.setupSlicer(dv) # When binsize is specified, oneDslicer adds an extra bin to first/last spots. self.assertEqual(self.testslicer.nslice, (dvmax - dvmin) / binsize + 2) # Test that warning works. with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") self.testslicer = OneDSlicer(sliceColName='testdata', bins=200, binsize=binsize) self.testslicer.setupSlicer(dv) # Verify some things self.assertIn("binsize", str(w[-1].message)) def testSetupSlicerFreedman(self): """Test that setting up the slicer using bins=None works.""" dvmin = 0 dvmax = 1 dv = makeDataValues(1000, dvmin, dvmax, random=2234) self.testslicer = OneDSlicer(sliceColName='testdata', bins=None) self.testslicer.setupSlicer(dv) # How many bins do you expect from optimal binsize? from lsst.sims.maf.utils import optimalBins bins = optimalBins(dv['testdata']) np.testing.assert_equal(self.testslicer.nslice, bins)
def testEquivalence(self): """Test equals method.""" # Note that two OneD slicers will be considered equal if they are both the same kind of # slicer AND have the same bins. # Set up self.. dvmin = 0 dvmax = 1 nvalues = 1000 bins = np.arange(dvmin, dvmax, 0.01) dv = makeDataValues(nvalues, dvmin, dvmax, random=32499) self.testslicer = OneDSlicer(sliceColName='testdata', bins=bins) self.testslicer.setupSlicer(dv) # Set up another slicer to match (same bins, although not the same data). dv2 = makeDataValues(nvalues + 100, dvmin, dvmax, random=334) testslicer2 = OneDSlicer(sliceColName='testdata', bins=bins) testslicer2.setupSlicer(dv2) self.assertTrue(self.testslicer == testslicer2) self.assertFalse(self.testslicer != testslicer2) # Set up another slicer that should not match (different bins) dv2 = makeDataValues(nvalues, dvmin + 1, dvmax + 1, random=445) testslicer2 = OneDSlicer(sliceColName='testdata', bins=len(bins)) testslicer2.setupSlicer(dv2) self.assertTrue(self.testslicer != testslicer2) self.assertFalse(self.testslicer == testslicer2) # Set up a different kind of slicer that should not match. dv2 = makeDataValues(100, 0, 1, random=12) testslicer2 = UniSlicer() testslicer2.setupSlicer(dv2) self.assertTrue(self.testslicer != testslicer2) self.assertFalse(self.testslicer == testslicer2) # Get another oneDslicer that is not set up, and check equivalence. testslicer2 = OneDSlicer(sliceColName='testdata') self.assertTrue(self.testslicer != testslicer2) self.assertFalse(self.testslicer == testslicer2) testslicer2 = OneDSlicer(sliceColName='testdata', binMin=0, binMax=1, binsize=0.5) testslicer3 = OneDSlicer(sliceColName='testdata', binMin=0, binMax=1, binsize=0.5) self.assertTrue(testslicer2 == testslicer3) self.assertFalse(testslicer2 != testslicer3) testslicer3 = OneDSlicer(sliceColName='testdata', binMin=0, binMax=1) self.assertFalse(testslicer2 == testslicer3) self.assertTrue(testslicer2 != testslicer3) usebins = np.arange(0, 1, 0.1) testslicer2 = OneDSlicer(sliceColName='testdata', bins=usebins) testslicer3 = OneDSlicer(sliceColName='testdata', bins=usebins) self.assertTrue(testslicer2 == testslicer3) self.assertFalse(testslicer2 != testslicer3) testslicer3 = OneDSlicer(sliceColName='testdata', bins=usebins + 1) self.assertFalse(testslicer2 == testslicer3) self.assertTrue(testslicer2 != testslicer3)