summaryrefslogtreecommitdiff
path: root/testes/math.lua
diff options
context:
space:
mode:
authorRoberto Ierusalimschy <roberto@inf.puc-rio.br>2018-12-17 14:46:37 -0200
committerRoberto Ierusalimschy <roberto@inf.puc-rio.br>2018-12-17 14:46:37 -0200
commit063d4e4543088e7a21965bda8ee5a0f952a9029e (patch)
tree6c3f2f8e98c26f071a94a32f9f2754396a66a9de /testes/math.lua
parente354c6355e7f48e087678ec49e340ca0696725b1 (diff)
downloadlua-5.3.5.tar.gz
lua-5.3.5.tar.bz2
lua-5.3.5.zip
Lua 5.3.5 ported to gitv5.3.5
This is the first commit for the branch Lua 5.3. All source files were copied from the official distribution of 5.3.5 in the Lua site. The test files are the same of 5.3.4. The manual came from the previous RCS repository, revision 1.167.1.2.
Diffstat (limited to 'testes/math.lua')
-rw-r--r--testes/math.lua824
1 files changed, 824 insertions, 0 deletions
diff --git a/testes/math.lua b/testes/math.lua
new file mode 100644
index 00000000..53ce9b5a
--- /dev/null
+++ b/testes/math.lua
@@ -0,0 +1,824 @@
1-- $Id: math.lua,v 1.78 2016/11/07 13:11:28 roberto Exp $
2-- See Copyright Notice in file all.lua
3
4print("testing numbers and math lib")
5
6local minint = math.mininteger
7local maxint = math.maxinteger
8
9local intbits = math.floor(math.log(maxint, 2) + 0.5) + 1
10assert((1 << intbits) == 0)
11
12assert(minint == 1 << (intbits - 1))
13assert(maxint == minint - 1)
14
15-- number of bits in the mantissa of a floating-point number
16local floatbits = 24
17do
18 local p = 2.0^floatbits
19 while p < p + 1.0 do
20 p = p * 2.0
21 floatbits = floatbits + 1
22 end
23end
24
25local function isNaN (x)
26 return (x ~= x)
27end
28
29assert(isNaN(0/0))
30assert(not isNaN(1/0))
31
32
33do
34 local x = 2.0^floatbits
35 assert(x > x - 1.0 and x == x + 1.0)
36
37 print(string.format("%d-bit integers, %d-bit (mantissa) floats",
38 intbits, floatbits))
39end
40
41assert(math.type(0) == "integer" and math.type(0.0) == "float"
42 and math.type("10") == nil)
43
44
45local function checkerror (msg, f, ...)
46 local s, err = pcall(f, ...)
47 assert(not s and string.find(err, msg))
48end
49
50local msgf2i = "number.* has no integer representation"
51
52-- float equality
53function eq (a,b,limit)
54 if not limit then
55 if floatbits >= 50 then limit = 1E-11
56 else limit = 1E-5
57 end
58 end
59 -- a == b needed for +inf/-inf
60 return a == b or math.abs(a-b) <= limit
61end
62
63
64-- equality with types
65function eqT (a,b)
66 return a == b and math.type(a) == math.type(b)
67end
68
69
70-- basic float notation
71assert(0e12 == 0 and .0 == 0 and 0. == 0 and .2e2 == 20 and 2.E-1 == 0.2)
72
73do
74 local a,b,c = "2", " 3e0 ", " 10 "
75 assert(a+b == 5 and -b == -3 and b+"2" == 5 and "10"-c == 0)
76 assert(type(a) == 'string' and type(b) == 'string' and type(c) == 'string')
77 assert(a == "2" and b == " 3e0 " and c == " 10 " and -c == -" 10 ")
78 assert(c%a == 0 and a^b == 08)
79 a = 0
80 assert(a == -a and 0 == -0)
81end
82
83do
84 local x = -1
85 local mz = 0/x -- minus zero
86 t = {[0] = 10, 20, 30, 40, 50}
87 assert(t[mz] == t[0] and t[-0] == t[0])
88end
89
90do -- tests for 'modf'
91 local a,b = math.modf(3.5)
92 assert(a == 3.0 and b == 0.5)
93 a,b = math.modf(-2.5)
94 assert(a == -2.0 and b == -0.5)
95 a,b = math.modf(-3e23)
96 assert(a == -3e23 and b == 0.0)
97 a,b = math.modf(3e35)
98 assert(a == 3e35 and b == 0.0)
99 a,b = math.modf(-1/0) -- -inf
100 assert(a == -1/0 and b == 0.0)
101 a,b = math.modf(1/0) -- inf
102 assert(a == 1/0 and b == 0.0)
103 a,b = math.modf(0/0) -- NaN
104 assert(isNaN(a) and isNaN(b))
105 a,b = math.modf(3) -- integer argument
106 assert(eqT(a, 3) and eqT(b, 0.0))
107 a,b = math.modf(minint)
108 assert(eqT(a, minint) and eqT(b, 0.0))
109end
110
111assert(math.huge > 10e30)
112assert(-math.huge < -10e30)
113
114
115-- integer arithmetic
116assert(minint < minint + 1)
117assert(maxint - 1 < maxint)
118assert(0 - minint == minint)
119assert(minint * minint == 0)
120assert(maxint * maxint * maxint == maxint)
121
122
123-- testing floor division and conversions
124
125for _, i in pairs{-16, -15, -3, -2, -1, 0, 1, 2, 3, 15} do
126 for _, j in pairs{-16, -15, -3, -2, -1, 1, 2, 3, 15} do
127 for _, ti in pairs{0, 0.0} do -- try 'i' as integer and as float
128 for _, tj in pairs{0, 0.0} do -- try 'j' as integer and as float
129 local x = i + ti
130 local y = j + tj
131 assert(i//j == math.floor(i/j))
132 end
133 end
134 end
135end
136
137assert(1//0.0 == 1/0)
138assert(-1 // 0.0 == -1/0)
139assert(eqT(3.5 // 1.5, 2.0))
140assert(eqT(3.5 // -1.5, -3.0))
141
142assert(maxint // maxint == 1)
143assert(maxint // 1 == maxint)
144assert((maxint - 1) // maxint == 0)
145assert(maxint // (maxint - 1) == 1)
146assert(minint // minint == 1)
147assert(minint // minint == 1)
148assert((minint + 1) // minint == 0)
149assert(minint // (minint + 1) == 1)
150assert(minint // 1 == minint)
151
152assert(minint // -1 == -minint)
153assert(minint // -2 == 2^(intbits - 2))
154assert(maxint // -1 == -maxint)
155
156
157-- negative exponents
158do
159 assert(2^-3 == 1 / 2^3)
160 assert(eq((-3)^-3, 1 / (-3)^3))
161 for i = -3, 3 do -- variables avoid constant folding
162 for j = -3, 3 do
163 -- domain errors (0^(-n)) are not portable
164 if not _port or i ~= 0 or j > 0 then
165 assert(eq(i^j, 1 / i^(-j)))
166 end
167 end
168 end
169end
170
171-- comparison between floats and integers (border cases)
172if floatbits < intbits then
173 assert(2.0^floatbits == (1 << floatbits))
174 assert(2.0^floatbits - 1.0 == (1 << floatbits) - 1.0)
175 assert(2.0^floatbits - 1.0 ~= (1 << floatbits))
176 -- float is rounded, int is not
177 assert(2.0^floatbits + 1.0 ~= (1 << floatbits) + 1)
178else -- floats can express all integers with full accuracy
179 assert(maxint == maxint + 0.0)
180 assert(maxint - 1 == maxint - 1.0)
181 assert(minint + 1 == minint + 1.0)
182 assert(maxint ~= maxint - 1.0)
183end
184assert(maxint + 0.0 == 2.0^(intbits - 1) - 1.0)
185assert(minint + 0.0 == minint)
186assert(minint + 0.0 == -2.0^(intbits - 1))
187
188
189-- order between floats and integers
190assert(1 < 1.1); assert(not (1 < 0.9))
191assert(1 <= 1.1); assert(not (1 <= 0.9))
192assert(-1 < -0.9); assert(not (-1 < -1.1))
193assert(1 <= 1.1); assert(not (-1 <= -1.1))
194assert(-1 < -0.9); assert(not (-1 < -1.1))
195assert(-1 <= -0.9); assert(not (-1 <= -1.1))
196assert(minint <= minint + 0.0)
197assert(minint + 0.0 <= minint)
198assert(not (minint < minint + 0.0))
199assert(not (minint + 0.0 < minint))
200assert(maxint < minint * -1.0)
201assert(maxint <= minint * -1.0)
202
203do
204 local fmaxi1 = 2^(intbits - 1)
205 assert(maxint < fmaxi1)
206 assert(maxint <= fmaxi1)
207 assert(not (fmaxi1 <= maxint))
208 assert(minint <= -2^(intbits - 1))
209 assert(-2^(intbits - 1) <= minint)
210end
211
212if floatbits < intbits then
213 print("testing order (floats cannot represent all integers)")
214 local fmax = 2^floatbits
215 local ifmax = fmax | 0
216 assert(fmax < ifmax + 1)
217 assert(fmax - 1 < ifmax)
218 assert(-(fmax - 1) > -ifmax)
219 assert(not (fmax <= ifmax - 1))
220 assert(-fmax > -(ifmax + 1))
221 assert(not (-fmax >= -(ifmax - 1)))
222
223 assert(fmax/2 - 0.5 < ifmax//2)
224 assert(-(fmax/2 - 0.5) > -ifmax//2)
225
226 assert(maxint < 2^intbits)
227 assert(minint > -2^intbits)
228 assert(maxint <= 2^intbits)
229 assert(minint >= -2^intbits)
230else
231 print("testing order (floats can represent all integers)")
232 assert(maxint < maxint + 1.0)
233 assert(maxint < maxint + 0.5)
234 assert(maxint - 1.0 < maxint)
235 assert(maxint - 0.5 < maxint)
236 assert(not (maxint + 0.0 < maxint))
237 assert(maxint + 0.0 <= maxint)
238 assert(not (maxint < maxint + 0.0))
239 assert(maxint + 0.0 <= maxint)
240 assert(maxint <= maxint + 0.0)
241 assert(not (maxint + 1.0 <= maxint))
242 assert(not (maxint + 0.5 <= maxint))
243 assert(not (maxint <= maxint - 1.0))
244 assert(not (maxint <= maxint - 0.5))
245
246 assert(minint < minint + 1.0)
247 assert(minint < minint + 0.5)
248 assert(minint <= minint + 0.5)
249 assert(minint - 1.0 < minint)
250 assert(minint - 1.0 <= minint)
251 assert(not (minint + 0.0 < minint))
252 assert(not (minint + 0.5 < minint))
253 assert(not (minint < minint + 0.0))
254 assert(minint + 0.0 <= minint)
255 assert(minint <= minint + 0.0)
256 assert(not (minint + 1.0 <= minint))
257 assert(not (minint + 0.5 <= minint))
258 assert(not (minint <= minint - 1.0))
259end
260
261do
262 local NaN = 0/0
263 assert(not (NaN < 0))
264 assert(not (NaN > minint))
265 assert(not (NaN <= -9))
266 assert(not (NaN <= maxint))
267 assert(not (NaN < maxint))
268 assert(not (minint <= NaN))
269 assert(not (minint < NaN))
270end
271
272
273-- avoiding errors at compile time
274local function checkcompt (msg, code)
275 checkerror(msg, assert(load(code)))
276end
277checkcompt("divide by zero", "return 2 // 0")
278checkcompt(msgf2i, "return 2.3 >> 0")
279checkcompt(msgf2i, ("return 2.0^%d & 1"):format(intbits - 1))
280checkcompt("field 'huge'", "return math.huge << 1")
281checkcompt(msgf2i, ("return 1 | 2.0^%d"):format(intbits - 1))
282checkcompt(msgf2i, "return 2.3 ~ '0.0'")
283
284
285-- testing overflow errors when converting from float to integer (runtime)
286local function f2i (x) return x | x end
287checkerror(msgf2i, f2i, math.huge) -- +inf
288checkerror(msgf2i, f2i, -math.huge) -- -inf
289checkerror(msgf2i, f2i, 0/0) -- NaN
290
291if floatbits < intbits then
292 -- conversion tests when float cannot represent all integers
293 assert(maxint + 1.0 == maxint + 0.0)
294 assert(minint - 1.0 == minint + 0.0)
295 checkerror(msgf2i, f2i, maxint + 0.0)
296 assert(f2i(2.0^(intbits - 2)) == 1 << (intbits - 2))
297 assert(f2i(-2.0^(intbits - 2)) == -(1 << (intbits - 2)))
298 assert((2.0^(floatbits - 1) + 1.0) // 1 == (1 << (floatbits - 1)) + 1)
299 -- maximum integer representable as a float
300 local mf = maxint - (1 << (floatbits - intbits)) + 1
301 assert(f2i(mf + 0.0) == mf) -- OK up to here
302 mf = mf + 1
303 assert(f2i(mf + 0.0) ~= mf) -- no more representable
304else
305 -- conversion tests when float can represent all integers
306 assert(maxint + 1.0 > maxint)
307 assert(minint - 1.0 < minint)
308 assert(f2i(maxint + 0.0) == maxint)
309 checkerror("no integer rep", f2i, maxint + 1.0)
310 checkerror("no integer rep", f2i, minint - 1.0)
311end
312
313-- 'minint' should be representable as a float no matter the precision
314assert(f2i(minint + 0.0) == minint)
315
316
317-- testing numeric strings
318
319assert("2" + 1 == 3)
320assert("2 " + 1 == 3)
321assert(" -2 " + 1 == -1)
322assert(" -0xa " + 1 == -9)
323
324
325-- Literal integer Overflows (new behavior in 5.3.3)
326do
327 -- no overflows
328 assert(eqT(tonumber(tostring(maxint)), maxint))
329 assert(eqT(tonumber(tostring(minint)), minint))
330
331 -- add 1 to last digit as a string (it cannot be 9...)
332 local function incd (n)
333 local s = string.format("%d", n)
334 s = string.gsub(s, "%d$", function (d)
335 assert(d ~= '9')
336 return string.char(string.byte(d) + 1)
337 end)
338 return s
339 end
340
341 -- 'tonumber' with overflow by 1
342 assert(eqT(tonumber(incd(maxint)), maxint + 1.0))
343 assert(eqT(tonumber(incd(minint)), minint - 1.0))
344
345 -- large numbers
346 assert(eqT(tonumber("1"..string.rep("0", 30)), 1e30))
347 assert(eqT(tonumber("-1"..string.rep("0", 30)), -1e30))
348
349 -- hexa format still wraps around
350 assert(eqT(tonumber("0x1"..string.rep("0", 30)), 0))
351
352 -- lexer in the limits
353 assert(minint == load("return " .. minint)())
354 assert(eqT(maxint, load("return " .. maxint)()))
355
356 assert(eqT(10000000000000000000000.0, 10000000000000000000000))
357 assert(eqT(-10000000000000000000000.0, -10000000000000000000000))
358end
359
360
361-- testing 'tonumber'
362
363-- 'tonumber' with numbers
364assert(tonumber(3.4) == 3.4)
365assert(eqT(tonumber(3), 3))
366assert(eqT(tonumber(maxint), maxint) and eqT(tonumber(minint), minint))
367assert(tonumber(1/0) == 1/0)
368
369-- 'tonumber' with strings
370assert(tonumber("0") == 0)
371assert(tonumber("") == nil)
372assert(tonumber(" ") == nil)
373assert(tonumber("-") == nil)
374assert(tonumber(" -0x ") == nil)
375assert(tonumber{} == nil)
376assert(tonumber'+0.01' == 1/100 and tonumber'+.01' == 0.01 and
377 tonumber'.01' == 0.01 and tonumber'-1.' == -1 and
378 tonumber'+1.' == 1)
379assert(tonumber'+ 0.01' == nil and tonumber'+.e1' == nil and
380 tonumber'1e' == nil and tonumber'1.0e+' == nil and
381 tonumber'.' == nil)
382assert(tonumber('-012') == -010-2)
383assert(tonumber('-1.2e2') == - - -120)
384
385assert(tonumber("0xffffffffffff") == (1 << (4*12)) - 1)
386assert(tonumber("0x"..string.rep("f", (intbits//4))) == -1)
387assert(tonumber("-0x"..string.rep("f", (intbits//4))) == 1)
388
389-- testing 'tonumber' with base
390assert(tonumber(' 001010 ', 2) == 10)
391assert(tonumber(' 001010 ', 10) == 001010)
392assert(tonumber(' -1010 ', 2) == -10)
393assert(tonumber('10', 36) == 36)
394assert(tonumber(' -10 ', 36) == -36)
395assert(tonumber(' +1Z ', 36) == 36 + 35)
396assert(tonumber(' -1z ', 36) == -36 + -35)
397assert(tonumber('-fFfa', 16) == -(10+(16*(15+(16*(15+(16*15)))))))
398assert(tonumber(string.rep('1', (intbits - 2)), 2) + 1 == 2^(intbits - 2))
399assert(tonumber('ffffFFFF', 16)+1 == (1 << 32))
400assert(tonumber('0ffffFFFF', 16)+1 == (1 << 32))
401assert(tonumber('-0ffffffFFFF', 16) - 1 == -(1 << 40))
402for i = 2,36 do
403 local i2 = i * i
404 local i10 = i2 * i2 * i2 * i2 * i2 -- i^10
405 assert(tonumber('\t10000000000\t', i) == i10)
406end
407
408if not _soft then
409 -- tests with very long numerals
410 assert(tonumber("0x"..string.rep("f", 13)..".0") == 2.0^(4*13) - 1)
411 assert(tonumber("0x"..string.rep("f", 150)..".0") == 2.0^(4*150) - 1)
412 assert(tonumber("0x"..string.rep("f", 300)..".0") == 2.0^(4*300) - 1)
413 assert(tonumber("0x"..string.rep("f", 500)..".0") == 2.0^(4*500) - 1)
414 assert(tonumber('0x3.' .. string.rep('0', 1000)) == 3)
415 assert(tonumber('0x' .. string.rep('0', 1000) .. 'a') == 10)
416 assert(tonumber('0x0.' .. string.rep('0', 13).."1") == 2.0^(-4*14))
417 assert(tonumber('0x0.' .. string.rep('0', 150).."1") == 2.0^(-4*151))
418 assert(tonumber('0x0.' .. string.rep('0', 300).."1") == 2.0^(-4*301))
419 assert(tonumber('0x0.' .. string.rep('0', 500).."1") == 2.0^(-4*501))
420
421 assert(tonumber('0xe03' .. string.rep('0', 1000) .. 'p-4000') == 3587.0)
422 assert(tonumber('0x.' .. string.rep('0', 1000) .. '74p4004') == 0x7.4)
423end
424
425-- testing 'tonumber' for invalid formats
426
427local function f (...)
428 if select('#', ...) == 1 then
429 return (...)
430 else
431 return "***"
432 end
433end
434
435assert(f(tonumber('fFfa', 15)) == nil)
436assert(f(tonumber('099', 8)) == nil)
437assert(f(tonumber('1\0', 2)) == nil)
438assert(f(tonumber('', 8)) == nil)
439assert(f(tonumber(' ', 9)) == nil)
440assert(f(tonumber(' ', 9)) == nil)
441assert(f(tonumber('0xf', 10)) == nil)
442
443assert(f(tonumber('inf')) == nil)
444assert(f(tonumber(' INF ')) == nil)
445assert(f(tonumber('Nan')) == nil)
446assert(f(tonumber('nan')) == nil)
447
448assert(f(tonumber(' ')) == nil)
449assert(f(tonumber('')) == nil)
450assert(f(tonumber('1 a')) == nil)
451assert(f(tonumber('1 a', 2)) == nil)
452assert(f(tonumber('1\0')) == nil)
453assert(f(tonumber('1 \0')) == nil)
454assert(f(tonumber('1\0 ')) == nil)
455assert(f(tonumber('e1')) == nil)
456assert(f(tonumber('e 1')) == nil)
457assert(f(tonumber(' 3.4.5 ')) == nil)
458
459
460-- testing 'tonumber' for invalid hexadecimal formats
461
462assert(tonumber('0x') == nil)
463assert(tonumber('x') == nil)
464assert(tonumber('x3') == nil)
465assert(tonumber('0x3.3.3') == nil) -- two decimal points
466assert(tonumber('00x2') == nil)
467assert(tonumber('0x 2') == nil)
468assert(tonumber('0 x2') == nil)
469assert(tonumber('23x') == nil)
470assert(tonumber('- 0xaa') == nil)
471assert(tonumber('-0xaaP ') == nil) -- no exponent
472assert(tonumber('0x0.51p') == nil)
473assert(tonumber('0x5p+-2') == nil)
474
475
476-- testing hexadecimal numerals
477
478assert(0x10 == 16 and 0xfff == 2^12 - 1 and 0XFB == 251)
479assert(0x0p12 == 0 and 0x.0p-3 == 0)
480assert(0xFFFFFFFF == (1 << 32) - 1)
481assert(tonumber('+0x2') == 2)
482assert(tonumber('-0xaA') == -170)
483assert(tonumber('-0xffFFFfff') == -(1 << 32) + 1)
484
485-- possible confusion with decimal exponent
486assert(0E+1 == 0 and 0xE+1 == 15 and 0xe-1 == 13)
487
488
489-- floating hexas
490
491assert(tonumber(' 0x2.5 ') == 0x25/16)
492assert(tonumber(' -0x2.5 ') == -0x25/16)
493assert(tonumber(' +0x0.51p+8 ') == 0x51)
494assert(0x.FfffFFFF == 1 - '0x.00000001')
495assert('0xA.a' + 0 == 10 + 10/16)
496assert(0xa.aP4 == 0XAA)
497assert(0x4P-2 == 1)
498assert(0x1.1 == '0x1.' + '+0x.1')
499assert(0Xabcdef.0 == 0x.ABCDEFp+24)
500
501
502assert(1.1 == 1.+.1)
503assert(100.0 == 1E2 and .01 == 1e-2)
504assert(1111111111 - 1111111110 == 1000.00e-03)
505assert(1.1 == '1.'+'.1')
506assert(tonumber'1111111111' - tonumber'1111111110' ==
507 tonumber" +0.001e+3 \n\t")
508
509assert(0.1e-30 > 0.9E-31 and 0.9E30 < 0.1e31)
510
511assert(0.123456 > 0.123455)
512
513assert(tonumber('+1.23E18') == 1.23*10.0^18)
514
515-- testing order operators
516assert(not(1<1) and (1<2) and not(2<1))
517assert(not('a'<'a') and ('a'<'b') and not('b'<'a'))
518assert((1<=1) and (1<=2) and not(2<=1))
519assert(('a'<='a') and ('a'<='b') and not('b'<='a'))
520assert(not(1>1) and not(1>2) and (2>1))
521assert(not('a'>'a') and not('a'>'b') and ('b'>'a'))
522assert((1>=1) and not(1>=2) and (2>=1))
523assert(('a'>='a') and not('a'>='b') and ('b'>='a'))
524assert(1.3 < 1.4 and 1.3 <= 1.4 and not (1.3 < 1.3) and 1.3 <= 1.3)
525
526-- testing mod operator
527assert(eqT(-4 % 3, 2))
528assert(eqT(4 % -3, -2))
529assert(eqT(-4.0 % 3, 2.0))
530assert(eqT(4 % -3.0, -2.0))
531assert(math.pi - math.pi % 1 == 3)
532assert(math.pi - math.pi % 0.001 == 3.141)
533
534assert(eqT(minint % minint, 0))
535assert(eqT(maxint % maxint, 0))
536assert((minint + 1) % minint == minint + 1)
537assert((maxint - 1) % maxint == maxint - 1)
538assert(minint % maxint == maxint - 1)
539
540assert(minint % -1 == 0)
541assert(minint % -2 == 0)
542assert(maxint % -2 == -1)
543
544-- non-portable tests because Windows C library cannot compute
545-- fmod(1, huge) correctly
546if not _port then
547 local function anan (x) assert(isNaN(x)) end -- assert Not a Number
548 anan(0.0 % 0)
549 anan(1.3 % 0)
550 anan(math.huge % 1)
551 anan(math.huge % 1e30)
552 anan(-math.huge % 1e30)
553 anan(-math.huge % -1e30)
554 assert(1 % math.huge == 1)
555 assert(1e30 % math.huge == 1e30)
556 assert(1e30 % -math.huge == -math.huge)
557 assert(-1 % math.huge == math.huge)
558 assert(-1 % -math.huge == -1)
559end
560
561
562-- testing unsigned comparisons
563assert(math.ult(3, 4))
564assert(not math.ult(4, 4))
565assert(math.ult(-2, -1))
566assert(math.ult(2, -1))
567assert(not math.ult(-2, -2))
568assert(math.ult(maxint, minint))
569assert(not math.ult(minint, maxint))
570
571
572assert(eq(math.sin(-9.8)^2 + math.cos(-9.8)^2, 1))
573assert(eq(math.tan(math.pi/4), 1))
574assert(eq(math.sin(math.pi/2), 1) and eq(math.cos(math.pi/2), 0))
575assert(eq(math.atan(1), math.pi/4) and eq(math.acos(0), math.pi/2) and
576 eq(math.asin(1), math.pi/2))
577assert(eq(math.deg(math.pi/2), 90) and eq(math.rad(90), math.pi/2))
578assert(math.abs(-10.43) == 10.43)
579assert(eqT(math.abs(minint), minint))
580assert(eqT(math.abs(maxint), maxint))
581assert(eqT(math.abs(-maxint), maxint))
582assert(eq(math.atan(1,0), math.pi/2))
583assert(math.fmod(10,3) == 1)
584assert(eq(math.sqrt(10)^2, 10))
585assert(eq(math.log(2, 10), math.log(2)/math.log(10)))
586assert(eq(math.log(2, 2), 1))
587assert(eq(math.log(9, 3), 2))
588assert(eq(math.exp(0), 1))
589assert(eq(math.sin(10), math.sin(10%(2*math.pi))))
590
591
592assert(tonumber(' 1.3e-2 ') == 1.3e-2)
593assert(tonumber(' -1.00000000000001 ') == -1.00000000000001)
594
595-- testing constant limits
596-- 2^23 = 8388608
597assert(8388609 + -8388609 == 0)
598assert(8388608 + -8388608 == 0)
599assert(8388607 + -8388607 == 0)
600
601
602
603do -- testing floor & ceil
604 assert(eqT(math.floor(3.4), 3))
605 assert(eqT(math.ceil(3.4), 4))
606 assert(eqT(math.floor(-3.4), -4))
607 assert(eqT(math.ceil(-3.4), -3))
608 assert(eqT(math.floor(maxint), maxint))
609 assert(eqT(math.ceil(maxint), maxint))
610 assert(eqT(math.floor(minint), minint))
611 assert(eqT(math.floor(minint + 0.0), minint))
612 assert(eqT(math.ceil(minint), minint))
613 assert(eqT(math.ceil(minint + 0.0), minint))
614 assert(math.floor(1e50) == 1e50)
615 assert(math.ceil(1e50) == 1e50)
616 assert(math.floor(-1e50) == -1e50)
617 assert(math.ceil(-1e50) == -1e50)
618 for _, p in pairs{31,32,63,64} do
619 assert(math.floor(2^p) == 2^p)
620 assert(math.floor(2^p + 0.5) == 2^p)
621 assert(math.ceil(2^p) == 2^p)
622 assert(math.ceil(2^p - 0.5) == 2^p)
623 end
624 checkerror("number expected", math.floor, {})
625 checkerror("number expected", math.ceil, print)
626 assert(eqT(math.tointeger(minint), minint))
627 assert(eqT(math.tointeger(minint .. ""), minint))
628 assert(eqT(math.tointeger(maxint), maxint))
629 assert(eqT(math.tointeger(maxint .. ""), maxint))
630 assert(eqT(math.tointeger(minint + 0.0), minint))
631 assert(math.tointeger(0.0 - minint) == nil)
632 assert(math.tointeger(math.pi) == nil)
633 assert(math.tointeger(-math.pi) == nil)
634 assert(math.floor(math.huge) == math.huge)
635 assert(math.ceil(math.huge) == math.huge)
636 assert(math.tointeger(math.huge) == nil)
637 assert(math.floor(-math.huge) == -math.huge)
638 assert(math.ceil(-math.huge) == -math.huge)
639 assert(math.tointeger(-math.huge) == nil)
640 assert(math.tointeger("34.0") == 34)
641 assert(math.tointeger("34.3") == nil)
642 assert(math.tointeger({}) == nil)
643 assert(math.tointeger(0/0) == nil) -- NaN
644end
645
646
647-- testing fmod for integers
648for i = -6, 6 do
649 for j = -6, 6 do
650 if j ~= 0 then
651 local mi = math.fmod(i, j)
652 local mf = math.fmod(i + 0.0, j)
653 assert(mi == mf)
654 assert(math.type(mi) == 'integer' and math.type(mf) == 'float')
655 if (i >= 0 and j >= 0) or (i <= 0 and j <= 0) or mi == 0 then
656 assert(eqT(mi, i % j))
657 end
658 end
659 end
660end
661assert(eqT(math.fmod(minint, minint), 0))
662assert(eqT(math.fmod(maxint, maxint), 0))
663assert(eqT(math.fmod(minint + 1, minint), minint + 1))
664assert(eqT(math.fmod(maxint - 1, maxint), maxint - 1))
665
666checkerror("zero", math.fmod, 3, 0)
667
668
669do -- testing max/min
670 checkerror("value expected", math.max)
671 checkerror("value expected", math.min)
672 assert(eqT(math.max(3), 3))
673 assert(eqT(math.max(3, 5, 9, 1), 9))
674 assert(math.max(maxint, 10e60) == 10e60)
675 assert(eqT(math.max(minint, minint + 1), minint + 1))
676 assert(eqT(math.min(3), 3))
677 assert(eqT(math.min(3, 5, 9, 1), 1))
678 assert(math.min(3.2, 5.9, -9.2, 1.1) == -9.2)
679 assert(math.min(1.9, 1.7, 1.72) == 1.7)
680 assert(math.min(-10e60, minint) == -10e60)
681 assert(eqT(math.min(maxint, maxint - 1), maxint - 1))
682 assert(eqT(math.min(maxint - 2, maxint, maxint - 1), maxint - 2))
683end
684-- testing implicit convertions
685
686local a,b = '10', '20'
687assert(a*b == 200 and a+b == 30 and a-b == -10 and a/b == 0.5 and -b == -20)
688assert(a == '10' and b == '20')
689
690
691do
692 print("testing -0 and NaN")
693 local mz, z = -0.0, 0.0
694 assert(mz == z)
695 assert(1/mz < 0 and 0 < 1/z)
696 local a = {[mz] = 1}
697 assert(a[z] == 1 and a[mz] == 1)
698 a[z] = 2
699 assert(a[z] == 2 and a[mz] == 2)
700 local inf = math.huge * 2 + 1
701 mz, z = -1/inf, 1/inf
702 assert(mz == z)
703 assert(1/mz < 0 and 0 < 1/z)
704 local NaN = inf - inf
705 assert(NaN ~= NaN)
706 assert(not (NaN < NaN))
707 assert(not (NaN <= NaN))
708 assert(not (NaN > NaN))
709 assert(not (NaN >= NaN))
710 assert(not (0 < NaN) and not (NaN < 0))
711 local NaN1 = 0/0
712 assert(NaN ~= NaN1 and not (NaN <= NaN1) and not (NaN1 <= NaN))
713 local a = {}
714 assert(not pcall(rawset, a, NaN, 1))
715 assert(a[NaN] == nil)
716 a[1] = 1
717 assert(not pcall(rawset, a, NaN, 1))
718 assert(a[NaN] == nil)
719 -- strings with same binary representation as 0.0 (might create problems
720 -- for constant manipulation in the pre-compiler)
721 local a1, a2, a3, a4, a5 = 0, 0, "\0\0\0\0\0\0\0\0", 0, "\0\0\0\0\0\0\0\0"
722 assert(a1 == a2 and a2 == a4 and a1 ~= a3)
723 assert(a3 == a5)
724end
725
726
727print("testing 'math.random'")
728math.randomseed(0)
729
730do -- test random for floats
731 local max = -math.huge
732 local min = math.huge
733 for i = 0, 20000 do
734 local t = math.random()
735 assert(0 <= t and t < 1)
736 max = math.max(max, t)
737 min = math.min(min, t)
738 if eq(max, 1, 0.001) and eq(min, 0, 0.001) then
739 goto ok
740 end
741 end
742 -- loop ended without satisfing condition
743 assert(false)
744 ::ok::
745end
746
747do
748 local function aux (p, lim) -- test random for small intervals
749 local x1, x2
750 if #p == 1 then x1 = 1; x2 = p[1]
751 else x1 = p[1]; x2 = p[2]
752 end
753 local mark = {}; local count = 0 -- to check that all values appeared
754 for i = 0, lim or 2000 do
755 local t = math.random(table.unpack(p))
756 assert(x1 <= t and t <= x2)
757 if not mark[t] then -- new value
758 mark[t] = true
759 count = count + 1
760 end
761 if count == x2 - x1 + 1 then -- all values appeared; OK
762 goto ok
763 end
764 end
765 -- loop ended without satisfing condition
766 assert(false)
767 ::ok::
768 end
769
770 aux({-10,0})
771 aux({6})
772 aux({-10, 10})
773 aux({minint, minint})
774 aux({maxint, maxint})
775 aux({minint, minint + 9})
776 aux({maxint - 3, maxint})
777end
778
779do
780 local function aux(p1, p2) -- test random for large intervals
781 local max = minint
782 local min = maxint
783 local n = 200
784 local mark = {}; local count = 0 -- to count how many different values
785 for _ = 1, n do
786 local t = math.random(p1, p2)
787 max = math.max(max, t)
788 min = math.min(min, t)
789 if not mark[t] then -- new value
790 mark[t] = true
791 count = count + 1
792 end
793 end
794 -- at least 80% of values are different
795 assert(count >= n * 0.8)
796 -- min and max not too far from formal min and max
797 local diff = (p2 - p1) // 8
798 assert(min < p1 + diff and max > p2 - diff)
799 end
800 aux(0, maxint)
801 aux(1, maxint)
802 aux(minint, -1)
803 aux(minint // 2, maxint // 2)
804end
805
806for i=1,100 do
807 assert(math.random(maxint) > 0)
808 assert(math.random(minint, -1) < 0)
809end
810
811assert(not pcall(math.random, 1, 2, 3)) -- too many arguments
812
813-- empty interval
814assert(not pcall(math.random, minint + 1, minint))
815assert(not pcall(math.random, maxint, maxint - 1))
816assert(not pcall(math.random, maxint, minint))
817
818-- interval too large
819assert(not pcall(math.random, minint, 0))
820assert(not pcall(math.random, -1, maxint))
821assert(not pcall(math.random, minint // 2, maxint // 2 + 1))
822
823
824print('OK')