Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1from builtins import str 

2from builtins import zip 

3import matplotlib 

4matplotlib.use("Agg") 

5import numpy as np 

6import warnings 

7import unittest 

8from lsst.sims.maf.slicers.oneDSlicer import OneDSlicer 

9from lsst.sims.maf.slicers.uniSlicer import UniSlicer 

10import lsst.utils.tests 

11 

12 

13def makeDataValues(size=100, min=0., max=1., random=-1): 

14 """Generate a simple array of numbers, evenly arranged between min/max, but (optional) random order.""" 

15 datavalues = np.arange(0, size, dtype='float') 

16 datavalues *= (float(max) - float(min)) / (datavalues.max() - datavalues.min()) 

17 datavalues += min 

18 if random > 0: 

19 rng = np.random.RandomState(random) 

20 randorder = rng.rand(size) 

21 randind = np.argsort(randorder) 

22 datavalues = datavalues[randind] 

23 datavalues = np.array(list(zip(datavalues)), dtype=[('testdata', 'float')]) 

24 return datavalues 

25 

26 

27class TestOneDSlicerSetup(unittest.TestCase): 

28 

29 def setUp(self): 

30 self.testslicer = OneDSlicer(sliceColName='testdata') 

31 

32 def tearDown(self): 

33 del self.testslicer 

34 self.testslicer = None 

35 

36 def testSlicertype(self): 

37 """Test instantiation of slicer sets slicer type as expected.""" 

38 self.assertEqual(self.testslicer.slicerName, self.testslicer.__class__.__name__) 

39 self.assertEqual(self.testslicer.slicerName, 'OneDSlicer') 

40 

41 def testSetupSlicerBins(self): 

42 """Test setting up slicer using defined bins.""" 

43 dvmin = 0 

44 dvmax = 1 

45 nvalues = 1000 

46 bins = np.arange(dvmin, dvmax, 0.1) 

47 dv = makeDataValues(nvalues, dvmin, dvmax, random=4) 

48 # Used right bins? 

49 self.testslicer = OneDSlicer(sliceColName='testdata', bins=bins) 

50 self.testslicer.setupSlicer(dv) 

51 np.testing.assert_equal(self.testslicer.bins, bins) 

52 self.assertEqual(self.testslicer.nslice, len(bins)-1) 

53 

54 def testSetupSlicerNbins(self): 

55 """Test setting up slicer using bins as integer.""" 

56 for nvalues in (100, 1000, 10000): 

57 for nbins in (5, 25, 75): 

58 dvmin = 0 

59 dvmax = 1 

60 dv = makeDataValues(nvalues, dvmin, dvmax, random=-1) 

61 # Right number of bins? 

62 # expect two more 'bins' to accomodate padding on left/right 

63 self.testslicer = OneDSlicer(sliceColName='testdata', bins=nbins) 

64 self.testslicer.setupSlicer(dv) 

65 self.assertEqual(self.testslicer.nslice, nbins) 

66 # Bins of the right size? 

67 bindiff = np.diff(self.testslicer.bins) 

68 expectedbindiff = (dvmax - dvmin) / float(nbins) 

69 np.testing.assert_allclose(bindiff, expectedbindiff) 

70 

71 def testSetupSlicerNbinsZeros(self): 

72 """Test what happens if give slicer test data that is all single-value.""" 

73 dv = np.zeros(100, float) 

74 dv = np.array(list(zip(dv)), dtype=[('testdata', 'float')]) 

75 nbins = 10 

76 self.testslicer = OneDSlicer(sliceColName='testdata', bins=nbins) 

77 with warnings.catch_warnings(record=True) as w: 

78 warnings.simplefilter("always") 

79 self.testslicer.setupSlicer(dv) 

80 self.assertIn("creasing binMax", str(w[-1].message)) 

81 self.assertEqual(self.testslicer.nslice, nbins) 

82 

83 def testSetupSlicerEquivalent(self): 

84 """Test setting up slicer using defined bins and nbins is equal where expected.""" 

85 dvmin = 0 

86 dvmax = 1 

87 for nbins in (20, 50, 100, 105): 

88 bins = makeDataValues(nbins+1, dvmin, dvmax, random=-1) 

89 bins = bins['testdata'] 

90 for nvalues in (100, 1000, 10000): 

91 dv = makeDataValues(nvalues, dvmin, dvmax, random=11) 

92 self.testslicer = OneDSlicer(sliceColName='testdata', bins=bins) 

93 self.testslicer.setupSlicer(dv) 

94 np.testing.assert_allclose(self.testslicer.bins, bins) 

95 

96 def testSetupSlicerLimits(self): 

97 """Test setting up slicer using binMin/Max.""" 

98 binMin = 0 

99 binMax = 1 

100 nbins = 10 

101 dvmin = -.5 

102 dvmax = 1.5 

103 dv = makeDataValues(1000, dvmin, dvmax, random=342) 

104 self.testslicer = OneDSlicer(sliceColName='testdata', 

105 binMin=binMin, binMax=binMax, bins=nbins) 

106 self.testslicer.setupSlicer(dv) 

107 self.assertAlmostEqual(self.testslicer.bins.min(), binMin) 

108 self.assertAlmostEqual(self.testslicer.bins.max(), binMax) 

109 

110 def testSetupSlicerBinsize(self): 

111 """Test setting up slicer using binsize.""" 

112 dvmin = 0 

113 dvmax = 1 

114 dv = makeDataValues(1000, dvmin, dvmax, random=8977) 

115 # Test basic use. 

116 binsize = 0.5 

117 self.testslicer = OneDSlicer(sliceColName='testdata', binsize=binsize) 

118 self.testslicer.setupSlicer(dv) 

119 # When binsize is specified, oneDslicer adds an extra bin to first/last spots. 

120 self.assertEqual(self.testslicer.nslice, (dvmax-dvmin)/binsize+2) 

121 # Test that warning works. 

122 with warnings.catch_warnings(record=True) as w: 

123 warnings.simplefilter("always") 

124 self.testslicer = OneDSlicer(sliceColName='testdata', bins=200, binsize=binsize) 

125 self.testslicer.setupSlicer(dv) 

126 # Verify some things 

127 self.assertIn("binsize", str(w[-1].message)) 

128 

129 def testSetupSlicerFreedman(self): 

130 """Test that setting up the slicer using bins=None works.""" 

131 dvmin = 0 

132 dvmax = 1 

133 dv = makeDataValues(1000, dvmin, dvmax, random=2234) 

134 self.testslicer = OneDSlicer(sliceColName='testdata', bins=None) 

135 self.testslicer.setupSlicer(dv) 

136 # How many bins do you expect from optimal binsize? 

137 from lsst.sims.maf.utils import optimalBins 

138 bins = optimalBins(dv['testdata']) 

139 np.testing.assert_equal(self.testslicer.nslice, bins) 

140 

141 

142class TestOneDSlicerIteration(unittest.TestCase): 

143 

144 def setUp(self): 

145 self.testslicer = OneDSlicer(sliceColName='testdata') 

146 dvmin = 0 

147 dvmax = 1 

148 nvalues = 1000 

149 self.bins = np.arange(dvmin, dvmax, 0.01) 

150 dv = makeDataValues(nvalues, dvmin, dvmax, random=5678) 

151 self.testslicer = OneDSlicer(sliceColName='testdata', bins=self.bins) 

152 self.testslicer.setupSlicer(dv) 

153 

154 def tearDown(self): 

155 del self.testslicer 

156 self.testslicer = None 

157 

158 def testIteration(self): 

159 """Test iteration.""" 

160 for i, (s, b) in enumerate(zip(self.testslicer, self.bins)): 

161 self.assertEqual(s['slicePoint']['sid'], i) 

162 self.assertEqual(s['slicePoint']['binLeft'], b) 

163 

164 def testGetItem(self): 

165 """Test that can return an individual indexed values of the slicer.""" 

166 for i in ([0, 10, 20]): 

167 self.assertEqual(self.testslicer[i]['slicePoint']['sid'], i) 

168 self.assertEqual(self.testslicer[i]['slicePoint']['binLeft'], self.bins[i]) 

169 

170 

171class TestOneDSlicerEqual(unittest.TestCase): 

172 

173 def setUp(self): 

174 self.testslicer = OneDSlicer(sliceColName='testdata') 

175 

176 def tearDown(self): 

177 del self.testslicer 

178 self.testslicer = None 

179 

180 def testEquivalence(self): 

181 """Test equals method.""" 

182 # Note that two OneD slicers will be considered equal if they are both the same kind of 

183 # slicer AND have the same bins. 

184 # Set up self.. 

185 dvmin = 0 

186 dvmax = 1 

187 nvalues = 1000 

188 bins = np.arange(dvmin, dvmax, 0.01) 

189 dv = makeDataValues(nvalues, dvmin, dvmax, random=32499) 

190 self.testslicer = OneDSlicer(sliceColName='testdata', bins=bins) 

191 self.testslicer.setupSlicer(dv) 

192 # Set up another slicer to match (same bins, although not the same data). 

193 dv2 = makeDataValues(nvalues+100, dvmin, dvmax, random=334) 

194 testslicer2 = OneDSlicer(sliceColName='testdata', bins=bins) 

195 testslicer2.setupSlicer(dv2) 

196 self.assertTrue(self.testslicer == testslicer2) 

197 self.assertFalse(self.testslicer != testslicer2) 

198 # Set up another slicer that should not match (different bins) 

199 dv2 = makeDataValues(nvalues, dvmin+1, dvmax+1, random=445) 

200 testslicer2 = OneDSlicer(sliceColName='testdata', bins=len(bins)) 

201 testslicer2.setupSlicer(dv2) 

202 self.assertTrue(self.testslicer != testslicer2) 

203 self.assertFalse(self.testslicer == testslicer2) 

204 # Set up a different kind of slicer that should not match. 

205 dv2 = makeDataValues(100, 0, 1, random=12) 

206 testslicer2 = UniSlicer() 

207 testslicer2.setupSlicer(dv2) 

208 self.assertTrue(self.testslicer != testslicer2) 

209 self.assertFalse(self.testslicer == testslicer2) 

210 # Get another oneDslicer that is not set up, and check equivalence. 

211 testslicer2 = OneDSlicer(sliceColName='testdata') 

212 self.assertTrue(self.testslicer != testslicer2) 

213 self.assertFalse(self.testslicer == testslicer2) 

214 testslicer2 = OneDSlicer(sliceColName='testdata', binMin=0, binMax=1, binsize=0.5) 

215 testslicer3 = OneDSlicer(sliceColName='testdata', binMin=0, binMax=1, binsize=0.5) 

216 self.assertTrue(testslicer2 == testslicer3) 

217 self.assertFalse(testslicer2 != testslicer3) 

218 testslicer3 = OneDSlicer(sliceColName='testdata', binMin=0, binMax=1) 

219 self.assertFalse(testslicer2 == testslicer3) 

220 self.assertTrue(testslicer2 != testslicer3) 

221 usebins = np.arange(0, 1, 0.1) 

222 testslicer2 = OneDSlicer(sliceColName='testdata', bins=usebins) 

223 testslicer3 = OneDSlicer(sliceColName='testdata', bins=usebins) 

224 self.assertTrue(testslicer2 == testslicer3) 

225 self.assertFalse(testslicer2 != testslicer3) 

226 testslicer3 = OneDSlicer(sliceColName='testdata', bins=usebins+1) 

227 self.assertFalse(testslicer2 == testslicer3) 

228 self.assertTrue(testslicer2 != testslicer3) 

229 

230 

231class TestOneDSlicerSlicing(unittest.TestCase): 

232 

233 longMessage = True 

234 

235 def setUp(self): 

236 self.testslicer = OneDSlicer(sliceColName='testdata') 

237 

238 def tearDown(self): 

239 del self.testslicer 

240 self.testslicer = None 

241 

242 def testSlicing(self): 

243 """Test slicing.""" 

244 dvmin = 0 

245 dvmax = 1 

246 nbins = 100 

247 # Test that testbinner raises appropriate error before it's set up (first time) 

248 self.assertRaises(NotImplementedError, self.testslicer._sliceSimData, 0) 

249 for nvalues in (1000, 10000, 100000): 

250 dv = makeDataValues(nvalues, dvmin, dvmax, random=560) 

251 self.testslicer = OneDSlicer(sliceColName='testdata', bins=nbins) 

252 self.testslicer.setupSlicer(dv) 

253 sum = 0 

254 for i, s in enumerate(self.testslicer): 

255 idxs = s['idxs'] 

256 dataslice = dv['testdata'][idxs] 

257 sum += len(idxs) 

258 if len(dataslice) > 0: 

259 self.assertEqual(len(dataslice), nvalues/float(nbins)) 

260 else: 

261 self.assertGreater(len(dataslice), 0, 

262 msg='Data in test case expected to always be > 0 len after slicing') 

263 self.assertTrue(sum, nvalues) 

264 

265 

266class TestMemory(lsst.utils.tests.MemoryTestCase): 

267 pass 

268 

269 

270def setup_module(module): 

271 lsst.utils.tests.init() 

272 

273 

274if __name__ == "__main__": 274 ↛ 275line 274 didn't jump to line 275, because the condition on line 274 was never true

275 lsst.utils.tests.init() 

276 unittest.main()