Back to index

python3.2  3.2.2
Public Member Functions
test.test_float.GeneralFloatCases Class Reference

List of all members.

Public Member Functions

def test_float
def test_error_message
def test_float_with_comma
def test_floatconversion
def test_floatasratio
def test_float_containment
def assertEqualAndEqualSign
def test_float_mod
def test_float_pow

Detailed Description

Definition at line 24 of file test_float.py.


Member Function Documentation

Definition at line 189 of file test_float.py.

00189 
00190     def assertEqualAndEqualSign(self, a, b):
00191         # fail unless a == b and a and b have the same sign bit;
00192         # the only difference from assertEqual is that this test
00193         # distinguishes -0.0 and 0.0.
00194         self.assertEqual((a, copysign(1.0, a)), (b, copysign(1.0, b)))

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 55 of file test_float.py.

00055 
00056     def test_error_message(self):
00057         testlist = ('\xbd', '123\xbd', '  123 456  ')
00058         for s in testlist:
00059             try:
00060                 float(s)
00061             except ValueError as e:
00062                 self.assertIn(s.strip(), e.args[0])
00063             else:
00064                 self.fail("Expected int(%r) to raise a ValueError", s)
00065 

Here is the call graph for this function:

Definition at line 26 of file test_float.py.

00026 
00027     def test_float(self):
00028         self.assertEqual(float(3.14), 3.14)
00029         self.assertEqual(float(314), 314.0)
00030         self.assertEqual(float("  3.14  "), 3.14)
00031         self.assertEqual(float(b" 3.14  "), 3.14)
00032         self.assertRaises(ValueError, float, "  0x3.1  ")
00033         self.assertRaises(ValueError, float, "  -0x3.p-1  ")
00034         self.assertRaises(ValueError, float, "  +0x3.p-1  ")
00035         self.assertRaises(ValueError, float, "++3.14")
00036         self.assertRaises(ValueError, float, "+-3.14")
00037         self.assertRaises(ValueError, float, "-+3.14")
00038         self.assertRaises(ValueError, float, "--3.14")
00039         self.assertRaises(ValueError, float, ".nan")
00040         self.assertRaises(ValueError, float, "+.inf")
00041         self.assertRaises(ValueError, float, ".")
00042         self.assertRaises(ValueError, float, "-.")
00043         self.assertRaises(ValueError, float, b"-")
00044         self.assertRaises(TypeError, float, {})
00045         # Lone surrogate
00046         self.assertRaises(UnicodeEncodeError, float, '\uD8F0')
00047         # check that we don't accept alternate exponent markers
00048         self.assertRaises(ValueError, float, "-1.7d29")
00049         self.assertRaises(ValueError, float, "3D-14")
00050         self.assertEqual(float("  \u0663.\u0661\u0664  "), 3.14)
00051         self.assertEqual(float("\N{EM SPACE}3.14\N{EN SPACE}"), 3.14)
00052         # extra long strings should not be a problem
00053         float(b'.' + b'1'*1000)
00054         float('.' + '1'*1000)

Here is the call graph for this function:

Definition at line 164 of file test_float.py.

00164 
00165     def test_float_containment(self):
00166         floats = (INF, -INF, 0.0, 1.0, NAN)
00167         for f in floats:
00168             self.assertIn(f, [f])
00169             self.assertIn(f, (f,))
00170             self.assertIn(f, {f})
00171             self.assertIn(f, {f: None})
00172             self.assertEqual([f].count(f), 1, "[].count('%r') != 1" % f)
00173             self.assertIn(f, floats)
00174 
00175         for f in floats:
00176             # nonidentical containers, same type, same contents
00177             self.assertTrue([f] == [f], "[%r] != [%r]" % (f, f))
00178             self.assertTrue((f,) == (f,), "(%r,) != (%r,)" % (f, f))
00179             self.assertTrue({f} == {f}, "{%r} != {%r}" % (f, f))
00180             self.assertTrue({f : None} == {f: None}, "{%r : None} != "
00181                                                    "{%r : None}" % (f, f))
00182 
00183             # identical containers
00184             l, t, s, d = [f], (f,), {f}, {f: None}
00185             self.assertTrue(l == l, "[%r] not equal to itself" % f)
00186             self.assertTrue(t == t, "(%r,) not equal to itself" % f)
00187             self.assertTrue(s == s, "{%r} not equal to itself" % f)
00188             self.assertTrue(d == d, "{%r : None} not equal to itself" % f)

Here is the call graph for this function:

Definition at line 196 of file test_float.py.

00196 
00197     def test_float_mod(self):
00198         # Check behaviour of % operator for IEEE 754 special cases.
00199         # In particular, check signs of zeros.
00200         mod = operator.mod
00201 
00202         self.assertEqualAndEqualSign(mod(-1.0, 1.0), 0.0)
00203         self.assertEqualAndEqualSign(mod(-1e-100, 1.0), 1.0)
00204         self.assertEqualAndEqualSign(mod(-0.0, 1.0), 0.0)
00205         self.assertEqualAndEqualSign(mod(0.0, 1.0), 0.0)
00206         self.assertEqualAndEqualSign(mod(1e-100, 1.0), 1e-100)
00207         self.assertEqualAndEqualSign(mod(1.0, 1.0), 0.0)
00208 
00209         self.assertEqualAndEqualSign(mod(-1.0, -1.0), -0.0)
00210         self.assertEqualAndEqualSign(mod(-1e-100, -1.0), -1e-100)
00211         self.assertEqualAndEqualSign(mod(-0.0, -1.0), -0.0)
00212         self.assertEqualAndEqualSign(mod(0.0, -1.0), -0.0)
00213         self.assertEqualAndEqualSign(mod(1e-100, -1.0), -1.0)
00214         self.assertEqualAndEqualSign(mod(1.0, -1.0), -0.0)

Here is the call graph for this function:

Definition at line 216 of file test_float.py.

00216 
00217     def test_float_pow(self):
00218         # test builtin pow and ** operator for IEEE 754 special cases.
00219         # Special cases taken from section F.9.4.4 of the C99 specification
00220 
00221         for pow_op in pow, operator.pow:
00222             # x**NAN is NAN for any x except 1
00223             self.assertTrue(isnan(pow_op(-INF, NAN)))
00224             self.assertTrue(isnan(pow_op(-2.0, NAN)))
00225             self.assertTrue(isnan(pow_op(-1.0, NAN)))
00226             self.assertTrue(isnan(pow_op(-0.5, NAN)))
00227             self.assertTrue(isnan(pow_op(-0.0, NAN)))
00228             self.assertTrue(isnan(pow_op(0.0, NAN)))
00229             self.assertTrue(isnan(pow_op(0.5, NAN)))
00230             self.assertTrue(isnan(pow_op(2.0, NAN)))
00231             self.assertTrue(isnan(pow_op(INF, NAN)))
00232             self.assertTrue(isnan(pow_op(NAN, NAN)))
00233 
00234             # NAN**y is NAN for any y except +-0
00235             self.assertTrue(isnan(pow_op(NAN, -INF)))
00236             self.assertTrue(isnan(pow_op(NAN, -2.0)))
00237             self.assertTrue(isnan(pow_op(NAN, -1.0)))
00238             self.assertTrue(isnan(pow_op(NAN, -0.5)))
00239             self.assertTrue(isnan(pow_op(NAN, 0.5)))
00240             self.assertTrue(isnan(pow_op(NAN, 1.0)))
00241             self.assertTrue(isnan(pow_op(NAN, 2.0)))
00242             self.assertTrue(isnan(pow_op(NAN, INF)))
00243 
00244             # (+-0)**y raises ZeroDivisionError for y a negative odd integer
00245             self.assertRaises(ZeroDivisionError, pow_op, -0.0, -1.0)
00246             self.assertRaises(ZeroDivisionError, pow_op, 0.0, -1.0)
00247 
00248             # (+-0)**y raises ZeroDivisionError for y finite and negative
00249             # but not an odd integer
00250             self.assertRaises(ZeroDivisionError, pow_op, -0.0, -2.0)
00251             self.assertRaises(ZeroDivisionError, pow_op, -0.0, -0.5)
00252             self.assertRaises(ZeroDivisionError, pow_op, 0.0, -2.0)
00253             self.assertRaises(ZeroDivisionError, pow_op, 0.0, -0.5)
00254 
00255             # (+-0)**y is +-0 for y a positive odd integer
00256             self.assertEqualAndEqualSign(pow_op(-0.0, 1.0), -0.0)
00257             self.assertEqualAndEqualSign(pow_op(0.0, 1.0), 0.0)
00258 
00259             # (+-0)**y is 0 for y finite and positive but not an odd integer
00260             self.assertEqualAndEqualSign(pow_op(-0.0, 0.5), 0.0)
00261             self.assertEqualAndEqualSign(pow_op(-0.0, 2.0), 0.0)
00262             self.assertEqualAndEqualSign(pow_op(0.0, 0.5), 0.0)
00263             self.assertEqualAndEqualSign(pow_op(0.0, 2.0), 0.0)
00264 
00265             # (-1)**+-inf is 1
00266             self.assertEqualAndEqualSign(pow_op(-1.0, -INF), 1.0)
00267             self.assertEqualAndEqualSign(pow_op(-1.0, INF), 1.0)
00268 
00269             # 1**y is 1 for any y, even if y is an infinity or nan
00270             self.assertEqualAndEqualSign(pow_op(1.0, -INF), 1.0)
00271             self.assertEqualAndEqualSign(pow_op(1.0, -2.0), 1.0)
00272             self.assertEqualAndEqualSign(pow_op(1.0, -1.0), 1.0)
00273             self.assertEqualAndEqualSign(pow_op(1.0, -0.5), 1.0)
00274             self.assertEqualAndEqualSign(pow_op(1.0, -0.0), 1.0)
00275             self.assertEqualAndEqualSign(pow_op(1.0, 0.0), 1.0)
00276             self.assertEqualAndEqualSign(pow_op(1.0, 0.5), 1.0)
00277             self.assertEqualAndEqualSign(pow_op(1.0, 1.0), 1.0)
00278             self.assertEqualAndEqualSign(pow_op(1.0, 2.0), 1.0)
00279             self.assertEqualAndEqualSign(pow_op(1.0, INF), 1.0)
00280             self.assertEqualAndEqualSign(pow_op(1.0, NAN), 1.0)
00281 
00282             # x**+-0 is 1 for any x, even if x is a zero, infinity, or nan
00283             self.assertEqualAndEqualSign(pow_op(-INF, 0.0), 1.0)
00284             self.assertEqualAndEqualSign(pow_op(-2.0, 0.0), 1.0)
00285             self.assertEqualAndEqualSign(pow_op(-1.0, 0.0), 1.0)
00286             self.assertEqualAndEqualSign(pow_op(-0.5, 0.0), 1.0)
00287             self.assertEqualAndEqualSign(pow_op(-0.0, 0.0), 1.0)
00288             self.assertEqualAndEqualSign(pow_op(0.0, 0.0), 1.0)
00289             self.assertEqualAndEqualSign(pow_op(0.5, 0.0), 1.0)
00290             self.assertEqualAndEqualSign(pow_op(1.0, 0.0), 1.0)
00291             self.assertEqualAndEqualSign(pow_op(2.0, 0.0), 1.0)
00292             self.assertEqualAndEqualSign(pow_op(INF, 0.0), 1.0)
00293             self.assertEqualAndEqualSign(pow_op(NAN, 0.0), 1.0)
00294             self.assertEqualAndEqualSign(pow_op(-INF, -0.0), 1.0)
00295             self.assertEqualAndEqualSign(pow_op(-2.0, -0.0), 1.0)
00296             self.assertEqualAndEqualSign(pow_op(-1.0, -0.0), 1.0)
00297             self.assertEqualAndEqualSign(pow_op(-0.5, -0.0), 1.0)
00298             self.assertEqualAndEqualSign(pow_op(-0.0, -0.0), 1.0)
00299             self.assertEqualAndEqualSign(pow_op(0.0, -0.0), 1.0)
00300             self.assertEqualAndEqualSign(pow_op(0.5, -0.0), 1.0)
00301             self.assertEqualAndEqualSign(pow_op(1.0, -0.0), 1.0)
00302             self.assertEqualAndEqualSign(pow_op(2.0, -0.0), 1.0)
00303             self.assertEqualAndEqualSign(pow_op(INF, -0.0), 1.0)
00304             self.assertEqualAndEqualSign(pow_op(NAN, -0.0), 1.0)
00305 
00306             # x**y defers to complex pow for finite negative x and
00307             # non-integral y.
00308             self.assertEqual(type(pow_op(-2.0, -0.5)), complex)
00309             self.assertEqual(type(pow_op(-2.0, 0.5)), complex)
00310             self.assertEqual(type(pow_op(-1.0, -0.5)), complex)
00311             self.assertEqual(type(pow_op(-1.0, 0.5)), complex)
00312             self.assertEqual(type(pow_op(-0.5, -0.5)), complex)
00313             self.assertEqual(type(pow_op(-0.5, 0.5)), complex)
00314 
00315             # x**-INF is INF for abs(x) < 1
00316             self.assertEqualAndEqualSign(pow_op(-0.5, -INF), INF)
00317             self.assertEqualAndEqualSign(pow_op(-0.0, -INF), INF)
00318             self.assertEqualAndEqualSign(pow_op(0.0, -INF), INF)
00319             self.assertEqualAndEqualSign(pow_op(0.5, -INF), INF)
00320 
00321             # x**-INF is 0 for abs(x) > 1
00322             self.assertEqualAndEqualSign(pow_op(-INF, -INF), 0.0)
00323             self.assertEqualAndEqualSign(pow_op(-2.0, -INF), 0.0)
00324             self.assertEqualAndEqualSign(pow_op(2.0, -INF), 0.0)
00325             self.assertEqualAndEqualSign(pow_op(INF, -INF), 0.0)
00326 
00327             # x**INF is 0 for abs(x) < 1
00328             self.assertEqualAndEqualSign(pow_op(-0.5, INF), 0.0)
00329             self.assertEqualAndEqualSign(pow_op(-0.0, INF), 0.0)
00330             self.assertEqualAndEqualSign(pow_op(0.0, INF), 0.0)
00331             self.assertEqualAndEqualSign(pow_op(0.5, INF), 0.0)
00332 
00333             # x**INF is INF for abs(x) > 1
00334             self.assertEqualAndEqualSign(pow_op(-INF, INF), INF)
00335             self.assertEqualAndEqualSign(pow_op(-2.0, INF), INF)
00336             self.assertEqualAndEqualSign(pow_op(2.0, INF), INF)
00337             self.assertEqualAndEqualSign(pow_op(INF, INF), INF)
00338 
00339             # (-INF)**y is -0.0 for y a negative odd integer
00340             self.assertEqualAndEqualSign(pow_op(-INF, -1.0), -0.0)
00341 
00342             # (-INF)**y is 0.0 for y negative but not an odd integer
00343             self.assertEqualAndEqualSign(pow_op(-INF, -0.5), 0.0)
00344             self.assertEqualAndEqualSign(pow_op(-INF, -2.0), 0.0)
00345 
00346             # (-INF)**y is -INF for y a positive odd integer
00347             self.assertEqualAndEqualSign(pow_op(-INF, 1.0), -INF)
00348 
00349             # (-INF)**y is INF for y positive but not an odd integer
00350             self.assertEqualAndEqualSign(pow_op(-INF, 0.5), INF)
00351             self.assertEqualAndEqualSign(pow_op(-INF, 2.0), INF)
00352 
00353             # INF**y is INF for y positive
00354             self.assertEqualAndEqualSign(pow_op(INF, 0.5), INF)
00355             self.assertEqualAndEqualSign(pow_op(INF, 1.0), INF)
00356             self.assertEqualAndEqualSign(pow_op(INF, 2.0), INF)
00357 
00358             # INF**y is 0.0 for y negative
00359             self.assertEqualAndEqualSign(pow_op(INF, -2.0), 0.0)
00360             self.assertEqualAndEqualSign(pow_op(INF, -1.0), 0.0)
00361             self.assertEqualAndEqualSign(pow_op(INF, -0.5), 0.0)
00362 
00363             # basic checks not covered by the special cases above
00364             self.assertEqualAndEqualSign(pow_op(-2.0, -2.0), 0.25)
00365             self.assertEqualAndEqualSign(pow_op(-2.0, -1.0), -0.5)
00366             self.assertEqualAndEqualSign(pow_op(-2.0, -0.0), 1.0)
00367             self.assertEqualAndEqualSign(pow_op(-2.0, 0.0), 1.0)
00368             self.assertEqualAndEqualSign(pow_op(-2.0, 1.0), -2.0)
00369             self.assertEqualAndEqualSign(pow_op(-2.0, 2.0), 4.0)
00370             self.assertEqualAndEqualSign(pow_op(-1.0, -2.0), 1.0)
00371             self.assertEqualAndEqualSign(pow_op(-1.0, -1.0), -1.0)
00372             self.assertEqualAndEqualSign(pow_op(-1.0, -0.0), 1.0)
00373             self.assertEqualAndEqualSign(pow_op(-1.0, 0.0), 1.0)
00374             self.assertEqualAndEqualSign(pow_op(-1.0, 1.0), -1.0)
00375             self.assertEqualAndEqualSign(pow_op(-1.0, 2.0), 1.0)
00376             self.assertEqualAndEqualSign(pow_op(2.0, -2.0), 0.25)
00377             self.assertEqualAndEqualSign(pow_op(2.0, -1.0), 0.5)
00378             self.assertEqualAndEqualSign(pow_op(2.0, -0.0), 1.0)
00379             self.assertEqualAndEqualSign(pow_op(2.0, 0.0), 1.0)
00380             self.assertEqualAndEqualSign(pow_op(2.0, 1.0), 2.0)
00381             self.assertEqualAndEqualSign(pow_op(2.0, 2.0), 4.0)
00382 
00383             # 1 ** large and -1 ** large; some libms apparently
00384             # have problems with these
00385             self.assertEqualAndEqualSign(pow_op(1.0, -1e100), 1.0)
00386             self.assertEqualAndEqualSign(pow_op(1.0, 1e100), 1.0)
00387             self.assertEqualAndEqualSign(pow_op(-1.0, -1e100), 1.0)
00388             self.assertEqualAndEqualSign(pow_op(-1.0, 1e100), 1.0)
00389 
00390             # check sign for results that underflow to 0
00391             self.assertEqualAndEqualSign(pow_op(-2.0, -2000.0), 0.0)
00392             self.assertEqual(type(pow_op(-2.0, -2000.5)), complex)
00393             self.assertEqualAndEqualSign(pow_op(-2.0, -2001.0), -0.0)
00394             self.assertEqualAndEqualSign(pow_op(2.0, -2000.0), 0.0)
00395             self.assertEqualAndEqualSign(pow_op(2.0, -2000.5), 0.0)
00396             self.assertEqualAndEqualSign(pow_op(2.0, -2001.0), 0.0)
00397             self.assertEqualAndEqualSign(pow_op(-0.5, 2000.0), 0.0)
00398             self.assertEqual(type(pow_op(-0.5, 2000.5)), complex)
00399             self.assertEqualAndEqualSign(pow_op(-0.5, 2001.0), -0.0)
00400             self.assertEqualAndEqualSign(pow_op(0.5, 2000.0), 0.0)
00401             self.assertEqualAndEqualSign(pow_op(0.5, 2000.5), 0.0)
00402             self.assertEqualAndEqualSign(pow_op(0.5, 2001.0), 0.0)
00403 
00404             # check we don't raise an exception for subnormal results,
00405             # and validate signs.  Tests currently disabled, since
00406             # they fail on systems where a subnormal result from pow
00407             # is flushed to zero (e.g. Debian/ia64.)
00408             #self.assertTrue(0.0 < pow_op(0.5, 1048) < 1e-315)
00409             #self.assertTrue(0.0 < pow_op(-0.5, 1048) < 1e-315)
00410             #self.assertTrue(0.0 < pow_op(0.5, 1047) < 1e-315)
00411             #self.assertTrue(0.0 > pow_op(-0.5, 1047) > -1e-315)
00412             #self.assertTrue(0.0 < pow_op(2.0, -1048) < 1e-315)
00413             #self.assertTrue(0.0 < pow_op(-2.0, -1048) < 1e-315)
00414             #self.assertTrue(0.0 < pow_op(2.0, -1047) < 1e-315)
00415             #self.assertTrue(0.0 > pow_op(-2.0, -1047) > -1e-315)
00416 
00417 
@requires_setformat

Here is the call graph for this function:

Definition at line 67 of file test_float.py.

00067 
00068     def test_float_with_comma(self):
00069         # set locale to something that doesn't use '.' for the decimal point
00070         # float must not accept the locale specific decimal point but
00071         # it still has to accept the normal python syntax
00072         import locale
00073         if not locale.localeconv()['decimal_point'] == ',':
00074             return
00075 
00076         self.assertEqual(float("  3.14  "), 3.14)
00077         self.assertEqual(float("+3.14  "), 3.14)
00078         self.assertEqual(float("-3.14  "), -3.14)
00079         self.assertEqual(float(".14  "), .14)
00080         self.assertEqual(float("3.  "), 3.0)
00081         self.assertEqual(float("3.e3  "), 3000.0)
00082         self.assertEqual(float("3.2e3  "), 3200.0)
00083         self.assertEqual(float("2.5e-1  "), 0.25)
00084         self.assertEqual(float("5e-1"), 0.5)
00085         self.assertRaises(ValueError, float, "  3,14  ")
00086         self.assertRaises(ValueError, float, "  +3,14  ")
00087         self.assertRaises(ValueError, float, "  -3,14  ")
00088         self.assertRaises(ValueError, float, "  0x3.1  ")
00089         self.assertRaises(ValueError, float, "  -0x3.p-1  ")
00090         self.assertRaises(ValueError, float, "  +0x3.p-1  ")
00091         self.assertEqual(float("  25.e-1  "), 2.5)
00092         self.assertEqual(support.fcmp(float("  .25e-1  "), .025), 0)

Here is the call graph for this function:

Definition at line 131 of file test_float.py.

00131 
00132     def test_floatasratio(self):
00133         for f, ratio in [
00134                 (0.875, (7, 8)),
00135                 (-0.875, (-7, 8)),
00136                 (0.0, (0, 1)),
00137                 (11.5, (23, 2)),
00138             ]:
00139             self.assertEqual(f.as_integer_ratio(), ratio)
00140 
00141         for i in range(10000):
00142             f = random.random()
00143             f *= 10 ** random.randint(-100, 100)
00144             n, d = f.as_integer_ratio()
00145             self.assertEqual(float(n).__truediv__(d), f)
00146 
00147         R = fractions.Fraction
00148         self.assertEqual(R(0, 1),
00149                          R(*float(0.0).as_integer_ratio()))
00150         self.assertEqual(R(5, 2),
00151                          R(*float(2.5).as_integer_ratio()))
00152         self.assertEqual(R(1, 2),
00153                          R(*float(0.5).as_integer_ratio()))
00154         self.assertEqual(R(4728779608739021, 2251799813685248),
00155                          R(*float(2.1).as_integer_ratio()))
00156         self.assertEqual(R(-4728779608739021, 2251799813685248),
00157                          R(*float(-2.1).as_integer_ratio()))
00158         self.assertEqual(R(-2100, 1),
00159                          R(*float(-2100.0).as_integer_ratio()))
00160 
00161         self.assertRaises(OverflowError, float('inf').as_integer_ratio)
00162         self.assertRaises(OverflowError, float('-inf').as_integer_ratio)
00163         self.assertRaises(ValueError, float('nan').as_integer_ratio)

Here is the call graph for this function:

Definition at line 93 of file test_float.py.

00093 
00094     def test_floatconversion(self):
00095         # Make sure that calls to __float__() work properly
00096         class Foo0:
00097             def __float__(self):
00098                 return 42.
00099 
00100         class Foo1(object):
00101             def __float__(self):
00102                 return 42.
00103 
00104         class Foo2(float):
00105             def __float__(self):
00106                 return 42.
00107 
00108         class Foo3(float):
00109             def __new__(cls, value=0.):
00110                 return float.__new__(cls, 2*value)
00111 
00112             def __float__(self):
00113                 return self
00114 
00115         class Foo4(float):
00116             def __float__(self):
00117                 return 42
00118 
00119         # Issue 5759: __float__ not called on str subclasses (though it is on
00120         # unicode subclasses).
00121         class FooStr(str):
00122             def __float__(self):
00123                 return float(str(self)) + 1
00124 
00125         self.assertAlmostEqual(float(Foo0()), 42.)
00126         self.assertAlmostEqual(float(Foo1()), 42.)
00127         self.assertAlmostEqual(float(Foo2()), 42.)
00128         self.assertAlmostEqual(float(Foo3(21)), 42.)
00129         self.assertRaises(TypeError, float, Foo4(42))
00130         self.assertAlmostEqual(float(FooStr('8')), 9.)

Here is the call graph for this function:


The documentation for this class was generated from the following file: