1# Tests of Starlark 'float' 2# option:set 3 4load("assert.star", "assert") 5 6# TODO(adonovan): more tests: 7# - precision 8# - limits 9 10# type 11assert.eq(type(0.0), "float") 12 13# truth 14assert.true(123.0) 15assert.true(-1.0) 16assert.true(not 0.0) 17assert.true(-1.0e-45) 18assert.true(float("NaN")) 19 20# not iterable 21assert.fails(lambda: len(0.0), 'has no len') 22assert.fails(lambda: [x for x in 0.0], 'float value is not iterable') 23 24# literals 25assert.eq(type(1.234), "float") 26assert.eq(type(1e10), "float") 27assert.eq(type(1e+10), "float") 28assert.eq(type(1e-10), "float") 29assert.eq(type(1.234e10), "float") 30assert.eq(type(1.234e+10), "float") 31assert.eq(type(1.234e-10), "float") 32 33# int/float equality 34assert.eq(0.0, 0) 35assert.eq(0, 0.0) 36assert.eq(1.0, 1) 37assert.eq(1, 1.0) 38assert.true(1.23e45 != 1229999999999999973814869011019624571608236031) 39assert.true(1.23e45 == 1229999999999999973814869011019624571608236032) 40assert.true(1.23e45 != 1229999999999999973814869011019624571608236033) 41assert.true(1229999999999999973814869011019624571608236031 != 1.23e45) 42assert.true(1229999999999999973814869011019624571608236032 == 1.23e45) 43assert.true(1229999999999999973814869011019624571608236033 != 1.23e45) 44 45# loss of precision 46p53 = 1<<53 47assert.eq(float(p53-1), p53-1) 48assert.eq(float(p53+0), p53+0) 49assert.eq(float(p53+1), p53+0) # 50assert.eq(float(p53+2), p53+2) 51assert.eq(float(p53+3), p53+4) # 52assert.eq(float(p53+4), p53+4) 53assert.eq(float(p53+5), p53+4) # 54assert.eq(float(p53+6), p53+6) 55assert.eq(float(p53+7), p53+8) # 56assert.eq(float(p53+8), p53+8) 57 58# Regression test for https://github.com/google/starlark-go/issues/375. 59maxint64 = (1<<63)-1 60assert.eq(int(float(maxint64)), 9223372036854775808) 61 62assert.true(float(p53+1) != p53+1) # comparisons are exact 63assert.eq(float(p53+1) - (p53+1), 0) # arithmetic entails rounding 64 65assert.fails(lambda: {123.0: "f", 123: "i"}, "duplicate key: 123") 66 67# equal int/float values have same hash 68d = {123.0: "x"} 69d[123] = "y" 70assert.eq(len(d), 1) 71assert.eq(d[123.0], "y") 72 73# literals (mostly covered by scanner tests) 74assert.eq(str(0.), "0.0") 75assert.eq(str(.0), "0.0") 76assert.true(5.0 != 4.999999999999999) 77assert.eq(5.0, 4.9999999999999999) # both literals denote 5.0 78assert.eq(1.23e45, 1.23 * 1000000000000000000000000000000000000000000000) 79assert.eq(str(1.23e-45 - (1.23 / 1000000000000000000000000000000000000000000000)), "-1.5557538194652854e-61") 80 81nan = float("NaN") 82inf = float("+Inf") 83neginf = float("-Inf") 84negzero = (-1e-323 / 10) 85 86# -- arithmetic -- 87 88# +float, -float 89assert.eq(+(123.0), 123.0) 90assert.eq(-(123.0), -123.0) 91assert.eq(-(-(123.0)), 123.0) 92assert.eq(+(inf), inf) 93assert.eq(-(inf), neginf) 94assert.eq(-(neginf), inf) 95assert.eq(str(-(nan)), "nan") 96# + 97assert.eq(1.2e3 + 5.6e7, 5.60012e+07) 98assert.eq(1.2e3 + 1, 1201) 99assert.eq(1 + 1.2e3, 1201) 100assert.eq(str(1.2e3 + nan), "nan") 101assert.eq(inf + 0, inf) 102assert.eq(inf + 1, inf) 103assert.eq(inf + inf, inf) 104assert.eq(str(inf + neginf), "nan") 105# - 106assert.eq(1.2e3 - 5.6e7, -5.59988e+07) 107assert.eq(1.2e3 - 1, 1199) 108assert.eq(1 - 1.2e3, -1199) 109assert.eq(str(1.2e3 - nan), "nan") 110assert.eq(inf - 0, inf) 111assert.eq(inf - 1, inf) 112assert.eq(str(inf - inf), "nan") 113assert.eq(inf - neginf, inf) 114# * 115assert.eq(1.5e6 * 2.2e3, 3.3e9) 116assert.eq(1.5e6 * 123, 1.845e+08) 117assert.eq(123 * 1.5e6, 1.845e+08) 118assert.eq(str(1.2e3 * nan), "nan") 119assert.eq(str(inf * 0), "nan") 120assert.eq(inf * 1, inf) 121assert.eq(inf * inf, inf) 122assert.eq(inf * neginf, neginf) 123# % 124assert.eq(100.0 % 7.0, 2) 125assert.eq(100.0 % -7.0, -5) # NB: different from Go / Java 126assert.eq(-100.0 % 7.0, 5) # NB: different from Go / Java 127assert.eq(-100.0 % -7.0, -2) 128assert.eq(-100.0 % 7, 5) 129assert.eq(100 % 7.0, 2) 130assert.eq(str(1.2e3 % nan), "nan") 131assert.eq(str(inf % 1), "nan") 132assert.eq(str(inf % inf), "nan") 133assert.eq(str(inf % neginf), "nan") 134# / 135assert.eq(str(100.0 / 7.0), "14.285714285714286") 136assert.eq(str(100 / 7.0), "14.285714285714286") 137assert.eq(str(100.0 / 7), "14.285714285714286") 138assert.eq(str(100.0 / nan), "nan") 139# // 140assert.eq(100.0 // 7.0, 14) 141assert.eq(100 // 7.0, 14) 142assert.eq(100.0 // 7, 14) 143assert.eq(100.0 // -7.0, -15) 144assert.eq(100 // -7.0, -15) 145assert.eq(100.0 // -7, -15) 146assert.eq(str(1 // neginf), "-0.0") 147assert.eq(str(100.0 // nan), "nan") 148 149# addition 150assert.eq(0.0 + 1.0, 1.0) 151assert.eq(1.0 + 1.0, 2.0) 152assert.eq(1.25 + 2.75, 4.0) 153assert.eq(5.0 + 7.0, 12.0) 154assert.eq(5.1 + 7, 12.1) # float + int 155assert.eq(7 + 5.1, 12.1) # int + float 156 157# subtraction 158assert.eq(5.0 - 7.0, -2.0) 159assert.eq(5.1 - 7.1, -2.0) 160assert.eq(5.5 - 7, -1.5) 161assert.eq(5 - 7.5, -2.5) 162assert.eq(0.0 - 1.0, -1.0) 163 164# multiplication 165assert.eq(5.0 * 7.0, 35.0) 166assert.eq(5.5 * 2.5, 13.75) 167assert.eq(5.5 * 7, 38.5) 168assert.eq(5 * 7.1, 35.5) 169 170# real division (like Python 3) 171# The / operator is available only when the 'fp' dialect option is enabled. 172assert.eq(100.0 / 8.0, 12.5) 173assert.eq(100.0 / -8.0, -12.5) 174assert.eq(-100.0 / 8.0, -12.5) 175assert.eq(-100.0 / -8.0, 12.5) 176assert.eq(98.0 / 8.0, 12.25) 177assert.eq(98.0 / -8.0, -12.25) 178assert.eq(-98.0 / 8.0, -12.25) 179assert.eq(-98.0 / -8.0, 12.25) 180assert.eq(2.5 / 2.0, 1.25) 181assert.eq(2.5 / 2, 1.25) 182assert.eq(5 / 4.0, 1.25) 183assert.eq(5 / 4, 1.25) 184assert.fails(lambda: 1.0 / 0, "floating-point division by zero") 185assert.fails(lambda: 1.0 / 0.0, "floating-point division by zero") 186assert.fails(lambda: 1 / 0.0, "floating-point division by zero") 187 188# floored division 189assert.eq(100.0 // 8.0, 12.0) 190assert.eq(100.0 // -8.0, -13.0) 191assert.eq(-100.0 // 8.0, -13.0) 192assert.eq(-100.0 // -8.0, 12.0) 193assert.eq(98.0 // 8.0, 12.0) 194assert.eq(98.0 // -8.0, -13.0) 195assert.eq(-98.0 // 8.0, -13.0) 196assert.eq(-98.0 // -8.0, 12.0) 197assert.eq(2.5 // 2.0, 1.0) 198assert.eq(2.5 // 2, 1.0) 199assert.eq(5 // 4.0, 1.0) 200assert.eq(5 // 4, 1) 201assert.eq(type(5 // 4), "int") 202assert.fails(lambda: 1.0 // 0, "floored division by zero") 203assert.fails(lambda: 1.0 // 0.0, "floored division by zero") 204assert.fails(lambda: 1 // 0.0, "floored division by zero") 205 206# remainder 207assert.eq(100.0 % 8.0, 4.0) 208assert.eq(100.0 % -8.0, -4.0) 209assert.eq(-100.0 % 8.0, 4.0) 210assert.eq(-100.0 % -8.0, -4.0) 211assert.eq(98.0 % 8.0, 2.0) 212assert.eq(98.0 % -8.0, -6.0) 213assert.eq(-98.0 % 8.0, 6.0) 214assert.eq(-98.0 % -8.0, -2.0) 215assert.eq(2.5 % 2.0, 0.5) 216assert.eq(2.5 % 2, 0.5) 217assert.eq(5 % 4.0, 1.0) 218assert.fails(lambda: 1.0 % 0, "floating-point modulo by zero") 219assert.fails(lambda: 1.0 % 0.0, "floating-point modulo by zero") 220assert.fails(lambda: 1 % 0.0, "floating-point modulo by zero") 221 222# floats cannot be used as indices, even if integral 223assert.fails(lambda: "abc"[1.0], "want int") 224assert.fails(lambda: ["A", "B", "C"].insert(1.0, "D"), "want int") 225assert.fails(lambda: range(3)[1.0], "got float, want int") 226 227# -- comparisons -- 228# NaN 229assert.true(nan == nan) # \ 230assert.true(nan >= nan) # unlike Python 231assert.true(nan <= nan) # / 232assert.true(not (nan > nan)) 233assert.true(not (nan < nan)) 234assert.true(not (nan != nan)) # unlike Python 235# Sort is stable: 0.0 and -0.0 are equal, but they are not permuted. 236# Similarly 1 and 1.0. 237assert.eq( 238 str(sorted([inf, neginf, nan, 1e300, -1e300, 1.0, -1.0, 1, -1, 1e-300, -1e-300, 0, 0.0, negzero, 1e-300, -1e-300])), 239 "[-inf, -1e+300, -1.0, -1, -1e-300, -1e-300, 0, 0.0, -0.0, 1e-300, 1e-300, 1.0, 1, 1e+300, +inf, nan]") 240 241# Sort is stable, and its result contains no adjacent x, y such that y > x. 242# Note: Python's reverse sort is unstable; see https://bugs.python.org/issue36095. 243assert.eq(str(sorted([7, 3, nan, 1, 9])), "[1, 3, 7, 9, nan]") 244assert.eq(str(sorted([7, 3, nan, 1, 9], reverse=True)), "[nan, 9, 7, 3, 1]") 245 246# All NaN values compare equal. (Identical objects compare equal.) 247nandict = {nan: 1} 248nandict[nan] = 2 249assert.eq(len(nandict), 1) # (same as Python) 250assert.eq(nandict[nan], 2) # (same as Python) 251assert.fails(lambda: {nan: 1, nan: 2}, "duplicate key: nan") 252 253nandict[float('nan')] = 3 # a distinct NaN object 254assert.eq(str(nandict), "{nan: 3}") # (Python: {nan: 2, nan: 3}) 255 256assert.eq(str({inf: 1, neginf: 2}), "{+inf: 1, -inf: 2}") 257 258# zero 259assert.eq(0.0, negzero) 260 261# inf 262assert.eq(+inf / +inf, nan) 263assert.eq(+inf / -inf, nan) 264assert.eq(-inf / +inf, nan) 265assert.eq(0.0 / +inf, 0.0) 266assert.eq(0.0 / -inf, 0.0) 267assert.true(inf > -inf) 268assert.eq(inf, -neginf) 269# TODO(adonovan): assert inf > any finite number, etc. 270 271# negative zero 272negz = -0 273assert.eq(negz, 0) 274 275# min/max ordering with NaN (the greatest float value) 276assert.eq(max([1, nan, 3]), nan) 277assert.eq(max([nan, 2, 3]), nan) 278assert.eq(min([1, nan, 3]), 1) 279assert.eq(min([nan, 2, 3]), 2) 280 281# float/float comparisons 282fltmax = 1.7976931348623157e+308 # approx 283fltmin = 4.9406564584124654e-324 # approx 284assert.lt(-inf, -fltmax) 285assert.lt(-fltmax, -1.0) 286assert.lt(-1.0, -fltmin) 287assert.lt(-fltmin, 0.0) 288assert.lt(0, fltmin) 289assert.lt(fltmin, 1.0) 290assert.lt(1.0, fltmax) 291assert.lt(fltmax, inf) 292 293# int/float comparisons 294assert.eq(0, 0.0) 295assert.eq(1, 1.0) 296assert.eq(-1, -1.0) 297assert.ne(-1, -1.0 + 1e-7) 298assert.lt(-2, -2 + 1e-15) 299 300# int conversion (rounds towards zero) 301assert.eq(int(100.1), 100) 302assert.eq(int(100.0), 100) 303assert.eq(int(99.9), 99) 304assert.eq(int(-99.9), -99) 305assert.eq(int(-100.0), -100) 306assert.eq(int(-100.1), -100) 307assert.eq(int(1e100), int("10000000000000000159028911097599180468360808563945281389781327557747838772170381060813469985856815104")) 308assert.fails(lambda: int(inf), "cannot convert.*infinity") 309assert.fails(lambda: int(nan), "cannot convert.*NaN") 310 311# -- float() function -- 312assert.eq(float(), 0.0) 313# float(bool) 314assert.eq(float(False), 0.0) 315assert.eq(float(True), 1.0) 316# float(int) 317assert.eq(float(0), 0.0) 318assert.eq(float(1), 1.0) 319assert.eq(float(123), 123.0) 320assert.eq(float(123 * 1000000 * 1000000 * 1000000 * 1000000 * 1000000), 1.23e+32) 321# float(float) 322assert.eq(float(1.1), 1.1) 323assert.fails(lambda: float(None), "want number or string") 324assert.ne(False, 0.0) # differs from Python 325assert.ne(True, 1.0) 326# float(string) 327assert.eq(float("1.1"), 1.1) 328assert.fails(lambda: float("1.1abc"), "invalid float literal") 329assert.fails(lambda: float("1e100.0"), "invalid float literal") 330assert.fails(lambda: float("1e1000"), "floating-point number too large") 331assert.eq(float("-1.1"), -1.1) 332assert.eq(float("+1.1"), +1.1) 333assert.eq(float("+Inf"), inf) 334assert.eq(float("-Inf"), neginf) 335assert.eq(float("NaN"), nan) 336assert.eq(float("NaN"), nan) 337assert.eq(float("+NAN"), nan) 338assert.eq(float("-nan"), nan) 339assert.eq(str(float("Inf")), "+inf") 340assert.eq(str(float("+INF")), "+inf") 341assert.eq(str(float("-inf")), "-inf") 342assert.eq(str(float("+InFiniTy")), "+inf") 343assert.eq(str(float("-iNFiniTy")), "-inf") 344assert.fails(lambda: float("one point two"), "invalid float literal: one point two") 345assert.fails(lambda: float("1.2.3"), "invalid float literal: 1.2.3") 346assert.fails(lambda: float(123 << 500 << 500 << 50), "int too large to convert to float") 347assert.fails(lambda: float(-123 << 500 << 500 << 50), "int too large to convert to float") 348assert.fails(lambda: float(str(-123 << 500 << 500 << 50)), "floating-point number too large") 349 350# -- implicit float(int) conversions -- 351assert.fails(lambda: (1<<500<<500<<500) + 0.0, "int too large to convert to float") 352assert.fails(lambda: 0.0 + (1<<500<<500<<500), "int too large to convert to float") 353assert.fails(lambda: (1<<500<<500<<500) - 0.0, "int too large to convert to float") 354assert.fails(lambda: 0.0 - (1<<500<<500<<500), "int too large to convert to float") 355assert.fails(lambda: (1<<500<<500<<500) * 1.0, "int too large to convert to float") 356assert.fails(lambda: 1.0 * (1<<500<<500<<500), "int too large to convert to float") 357assert.fails(lambda: (1<<500<<500<<500) / 1.0, "int too large to convert to float") 358assert.fails(lambda: 1.0 / (1<<500<<500<<500), "int too large to convert to float") 359assert.fails(lambda: (1<<500<<500<<500) // 1.0, "int too large to convert to float") 360assert.fails(lambda: 1.0 // (1<<500<<500<<500), "int too large to convert to float") 361assert.fails(lambda: (1<<500<<500<<500) % 1.0, "int too large to convert to float") 362assert.fails(lambda: 1.0 % (1<<500<<500<<500), "int too large to convert to float") 363 364 365# -- int function -- 366assert.eq(int(0.0), 0) 367assert.eq(int(1.0), 1) 368assert.eq(int(1.1), 1) 369assert.eq(int(0.9), 0) 370assert.eq(int(-1.1), -1.0) 371assert.eq(int(-1.0), -1.0) 372assert.eq(int(-0.9), 0.0) 373assert.eq(int(1.23e+32), 123000000000000004979083645550592) 374assert.eq(int(-1.23e-32), 0) 375assert.eq(int(1.23e-32), 0) 376assert.fails(lambda: int(float("+Inf")), "cannot convert float infinity to integer") 377assert.fails(lambda: int(float("-Inf")), "cannot convert float infinity to integer") 378assert.fails(lambda: int(float("NaN")), "cannot convert float NaN to integer") 379 380 381# hash 382# Check that equal float and int values have the same internal hash. 383def checkhash(): 384 for a in [1.23e100, 1.23e10, 1.23e1, 1.23, 385 1, 4294967295, 8589934591, 9223372036854775807]: 386 for b in [a, -a, 1/a, -1/a]: 387 f = float(b) 388 i = int(b) 389 if f == i: 390 fh = {f: None} 391 ih = {i: None} 392 if fh != ih: 393 assert.true(False, "{%v: None} != {%v: None}: hashes vary" % fh, ih) 394checkhash() 395 396# string formatting 397 398# %d 399assert.eq("%d" % 0, "0") 400assert.eq("%d" % 0.0, "0") 401assert.eq("%d" % 123, "123") 402assert.eq("%d" % 123.0, "123") 403assert.eq("%d" % 1.23e45, "1229999999999999973814869011019624571608236032") 404# (see below for '%d' % NaN/Inf) 405assert.eq("%d" % negzero, "0") 406assert.fails(lambda: "%d" % float("NaN"), "cannot convert float NaN to integer") 407assert.fails(lambda: "%d" % float("+Inf"), "cannot convert float infinity to integer") 408assert.fails(lambda: "%d" % float("-Inf"), "cannot convert float infinity to integer") 409 410# %e 411assert.eq("%e" % 0, "0.000000e+00") 412assert.eq("%e" % 0.0, "0.000000e+00") 413assert.eq("%e" % 123, "1.230000e+02") 414assert.eq("%e" % 123.0, "1.230000e+02") 415assert.eq("%e" % 1.23e45, "1.230000e+45") 416assert.eq("%e" % -1.23e-45, "-1.230000e-45") 417assert.eq("%e" % nan, "nan") 418assert.eq("%e" % inf, "+inf") 419assert.eq("%e" % neginf, "-inf") 420assert.eq("%e" % negzero, "-0.000000e+00") 421assert.fails(lambda: "%e" % "123", "requires float, not str") 422# %f 423assert.eq("%f" % 0, "0.000000") 424assert.eq("%f" % 0.0, "0.000000") 425assert.eq("%f" % 123, "123.000000") 426assert.eq("%f" % 123.0, "123.000000") 427# Note: Starlark/Java emits 1230000000000000000000000000000000000000000000.000000. Why? 428assert.eq("%f" % 1.23e45, "1229999999999999973814869011019624571608236032.000000") 429assert.eq("%f" % -1.23e-45, "-0.000000") 430assert.eq("%f" % nan, "nan") 431assert.eq("%f" % inf, "+inf") 432assert.eq("%f" % neginf, "-inf") 433assert.eq("%f" % negzero, "-0.000000") 434assert.fails(lambda: "%f" % "123", "requires float, not str") 435# %g 436assert.eq("%g" % 0, "0.0") 437assert.eq("%g" % 0.0, "0.0") 438assert.eq("%g" % 123, "123.0") 439assert.eq("%g" % 123.0, "123.0") 440assert.eq("%g" % 1.110, "1.11") 441assert.eq("%g" % 1e5, "100000.0") 442assert.eq("%g" % 1e6, "1e+06") # Note: threshold of scientific notation is 1e17 in Starlark/Java 443assert.eq("%g" % 1.23e45, "1.23e+45") 444assert.eq("%g" % -1.23e-45, "-1.23e-45") 445assert.eq("%g" % nan, "nan") 446assert.eq("%g" % inf, "+inf") 447assert.eq("%g" % neginf, "-inf") 448assert.eq("%g" % negzero, "-0.0") 449# str uses %g 450assert.eq(str(0.0), "0.0") 451assert.eq(str(123.0), "123.0") 452assert.eq(str(1.23e45), "1.23e+45") 453assert.eq(str(-1.23e-45), "-1.23e-45") 454assert.eq(str(nan), "nan") 455assert.eq(str(inf), "+inf") 456assert.eq(str(neginf), "-inf") 457assert.eq(str(negzero), "-0.0") 458assert.fails(lambda: "%g" % "123", "requires float, not str") 459 460i0 = 1 461f0 = 1.0 462assert.eq(type(i0), "int") 463assert.eq(type(f0), "float") 464 465ops = { 466 '+': lambda x, y: x + y, 467 '-': lambda x, y: x - y, 468 '*': lambda x, y: x * y, 469 '/': lambda x, y: x / y, 470 '//': lambda x, y: x // y, 471 '%': lambda x, y: x % y, 472} 473 474# Check that if either argument is a float, so too is the result. 475def checktypes(): 476 want = set(""" 477int + int = int 478int + float = float 479float + int = float 480float + float = float 481int - int = int 482int - float = float 483float - int = float 484float - float = float 485int * int = int 486int * float = float 487float * int = float 488float * float = float 489int / int = float 490int / float = float 491float / int = float 492float / float = float 493int // int = int 494int // float = float 495float // int = float 496float // float = float 497int % int = int 498int % float = float 499float % int = float 500float % float = float 501"""[1:].splitlines()) 502 for opname in ("+", "-", "*", "/", "%"): 503 for x in [i0, f0]: 504 for y in [i0, f0]: 505 op = ops[opname] 506 got = "%s %s %s = %s" % (type(x), opname, type(y), type(op(x, y))) 507 assert.contains(want, got) 508checktypes() 509