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

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

# 

# LSST Data Management System 

# Copyright 2008-2013 LSST Corporation. 

# 

# This product includes software developed by the 

# LSST Project (http://www.lsst.org/). 

# 

# This program is free software: you can redistribute it and/or modify 

# it under the terms of the GNU General Public License as published by 

# the Free Software Foundation, either version 3 of the License, or 

# (at your option) any later version. 

# 

# This program is distributed in the hope that it will be useful, 

# but WITHOUT ANY WARRANTY; without even the implied warranty of 

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

# GNU General Public License for more details. 

# 

# You should have received a copy of the LSST License Statement and 

# the GNU General Public License along with this program. If not, 

# see <http://www.lsstcorp.org/LegalNotices/>. 

# 

"""Helper functions for comparing `lsst.pex.config.Config` instancess. 

 

Theses function should be use for any comparison in a `lsst.pex.Config.compare` 

or `lsst.pex.config.Field._compare` implementation, as they take care of 

writing messages as well as floating-point comparisons and shortcuts. 

""" 

 

import numpy 

 

__all__ = ("getComparisonName", "compareScalars", "compareConfigs") 

 

 

def getComparisonName(name1, name2): 

"""Create a comparison name that is used for printed output of comparisons. 

 

Parameters 

---------- 

name1 : `str` 

Name of the first configuration. 

name2 : `str` 

Name of the second configuration. 

 

Returns 

------- 

name : `str` 

When ``name1`` and ``name2`` are equal, the returned name is 

simply one of the names. When they are different the returned name is 

formatted as ``"{name1} / {name2}"``. 

""" 

if name1 != name2: 

return "%s / %s" % (name1, name2) 

return name1 

 

 

def compareScalars(name, v1, v2, output, rtol=1E-8, atol=1E-8, dtype=None): 

"""Compare two scalar values for equality. 

 

This function is a helper for `lsst.pex.config.Config.compare`. 

 

Parameters 

---------- 

name : `str` 

Name to use when reporting differences, typically created by 

`getComparisonName`. 

v1 : object 

Left-hand side value to compare. 

v2 : object 

Right-hand side value to compare. 

output : callable or `None` 

A callable that takes a string, used (possibly repeatedly) to report 

inequalities (for example, `print`). Set to `None` to disable output. 

rtol : `float`, optional 

Relative tolerance for floating point comparisons. 

atol : `float`, optional 

Absolute tolerance for floating point comparisons. 

dtype : class, optional 

Data type of values for comparison. May be `None` if values are not 

floating-point. 

 

Returns 

------- 

areEqual : `bool` 

`True` if the values are equal, `False` if they are not. 

 

See also 

-------- 

lsst.pex.config.compareConfigs 

 

Notes 

----- 

Floating point comparisons are performed by `numpy.allclose`. 

""" 

if v1 is None or v2 is None: 

result = (v1 == v2) 

elif dtype in (float, complex): 

result = numpy.allclose(v1, v2, rtol=rtol, atol=atol) or (numpy.isnan(v1) and numpy.isnan(v2)) 

else: 

result = (v1 == v2) 

if not result and output is not None: 

output("Inequality in %s: %r != %r" % (name, v1, v2)) 

return result 

 

 

def compareConfigs(name, c1, c2, shortcut=True, rtol=1E-8, atol=1E-8, output=None): 

"""Compare two `lsst.pex.config.Config` instances for equality. 

 

This function is a helper for `lsst.pex.config.Config.compare`. 

 

Parameters 

---------- 

name : `str` 

Name to use when reporting differences, typically created by 

`getComparisonName`. 

v1 : `lsst.pex.config.Config` 

Left-hand side config to compare. 

v2 : `lsst.pex.config.Config` 

Right-hand side config to compare. 

shortcut : `bool`, optional 

If `True`, return as soon as an inequality is found. Default is `True`. 

rtol : `float`, optional 

Relative tolerance for floating point comparisons. 

atol : `float`, optional 

Absolute tolerance for floating point comparisons. 

output : callable, optional 

A callable that takes a string, used (possibly repeatedly) to report 

inequalities. For example: `print`. 

 

Returns 

------- 

areEqual : `bool` 

`True` when the two `lsst.pex.config.Config` instances are equal. 

`False` if there is an inequality. 

 

See also 

-------- 

lsst.pex.config.compareScalars 

 

Notes 

----- 

Floating point comparisons are performed by `numpy.allclose`. 

 

If ``c1`` or ``c2`` contain `~lsst.pex.config.RegistryField` or 

`~lsst.pex.config.ConfigChoiceField` instances, *unselected* 

`~lsst.pex.config.Config` instances will not be compared. 

""" 

assert name is not None 

if c1 is None: 

if c2 is None: 

return True 

else: 

if output is not None: 

output("LHS is None for %s" % name) 

return False 

else: 

if c2 is None: 

if output is not None: 

output("RHS is None for %s" % name) 

return False 

if type(c1) != type(c2): 

if output is not None: 

output("Config types do not match for %s: %s != %s" % (name, type(c1), type(c2))) 

return False 

equal = True 

for field in c1._fields.values(): 

result = field._compare(c1, c2, shortcut=shortcut, rtol=rtol, atol=atol, output=output) 

if not result and shortcut: 

return False 

equal = equal and result 

return equal