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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

from builtins import zip 

import matplotlib 

matplotlib.use("Agg") 

import numpy as np 

import unittest 

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

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

import lsst.utils.tests 

 

 

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

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

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

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

datavalues += min 

16 ↛ 21line 16 didn't jump to line 21, because the condition on line 16 was never false if random > 0: 

rng = np.random.RandomState(random) 

randorder = rng.rand(size) 

randind = np.argsort(randorder) 

datavalues = datavalues[randind] 

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

return datavalues 

 

 

class TestUniSlicerSetupAndSlice(unittest.TestCase): 

 

def setUp(self): 

self.testslicer = UniSlicer() 

 

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, 'UniSlicer') 

 

def testSlicerNbins(self): 

self.assertEqual(self.testslicer.nslice, 1) 

 

def testSetupSlicerIndices(self): 

"""Test slicer returns correct indices (all) after setup. Note this also tests slicing.""" 

dvmin = 0 

dvmax = 1 

nvalues = 1000 

dv = makeDataValues(nvalues, dvmin, dvmax, random=672) 

self.testslicer.setupSlicer(dv) 

# test slicing 

self.assertEqual(len(self.testslicer.indices), len(dv['testdata'])) 

np.testing.assert_equal(dv[self.testslicer.indices], dv) 

 

 

class TestUniSlicerIteration(unittest.TestCase): 

 

def setUp(self): 

self.testslicer = UniSlicer() 

 

def tearDown(self): 

del self.testslicer 

self.testslicer = None 

 

def testIteration(self): 

"""Test iteration -- which is a one-step identity op for a unislicer.""" 

dvmin = 0 

dvmax = 1 

nvalues = 1000 

dv = makeDataValues(nvalues, dvmin, dvmax, random=432) 

self.testslicer.setupSlicer(dv) 

for i, b in enumerate(self.testslicer): 

pass 

self.assertEqual(i, 0) 

 

def testGetItem(self): 

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

dvmin = 0 

dvmax = 1 

nvalues = 1000 

dv = makeDataValues(nvalues, dvmin, dvmax, random=1192) 

self.testslicer.setupSlicer(dv) 

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

 

 

class TestUniSlicerEqual(unittest.TestCase): 

 

def setUp(self): 

self.testslicer = UniSlicer() 

dvmin = 0 

dvmax = 1 

nvalues = 1000 

dv = makeDataValues(nvalues, dvmin, dvmax, random=3482) 

self.testslicer.setupSlicer(dv) 

 

def tearDown(self): 

del self.testslicer 

self.testslicer = None 

 

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) 

 

 

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

pass 

 

 

def setup_module(module): 

lsst.utils.tests.init() 

 

 

122 ↛ 123line 122 didn't jump to line 123, because the condition on line 122 was never trueif __name__ == "__main__": 

lsst.utils.tests.init() 

unittest.main()