394 lines
10 KiB
Lua
394 lines
10 KiB
Lua
require("tests")
|
|
|
|
-- Constants tests
|
|
test("math.pi", function()
|
|
assert_close(math.pi, 3.14159265358979323846)
|
|
assert(math.pi > 3.14 and math.pi < 3.15)
|
|
end)
|
|
|
|
test("math.tau", function()
|
|
assert_close(math.tau, 6.28318530717958647693)
|
|
assert_close(math.tau, 2 * math.pi)
|
|
end)
|
|
|
|
test("math.e", function()
|
|
assert_close(math.e, 2.71828182845904523536)
|
|
assert(math.e > 2.7 and math.e < 2.8)
|
|
end)
|
|
|
|
test("math.phi", function()
|
|
assert_close(math.phi, 1.61803398874989484820)
|
|
assert_close(math.phi, (1 + math.sqrt(5)) / 2)
|
|
end)
|
|
|
|
test("math.infinity", function()
|
|
assert_equal(math.infinity, 1/0)
|
|
assert(math.infinity > 0)
|
|
end)
|
|
|
|
test("math.nan", function()
|
|
assert_equal(math.isnan(math.nan), true)
|
|
assert(math.nan ~= math.nan) -- NaN property
|
|
end)
|
|
|
|
-- Extended functions tests
|
|
test("math.cbrt", function()
|
|
assert_close(math.cbrt(8), 2)
|
|
assert_close(math.cbrt(-8), -2)
|
|
end)
|
|
|
|
test("math.hypot", function()
|
|
assert_close(math.hypot(3, 4), 5)
|
|
assert_close(math.hypot(5, 12), 13)
|
|
end)
|
|
|
|
test("math.isnan", function()
|
|
assert_equal(math.isnan(0/0), true)
|
|
assert_equal(math.isnan(5), false)
|
|
end)
|
|
|
|
test("math.isfinite", function()
|
|
assert_equal(math.isfinite(5), true)
|
|
assert_equal(math.isfinite(math.infinity), false)
|
|
end)
|
|
|
|
test("math.sign", function()
|
|
assert_equal(math.sign(5), 1)
|
|
assert_equal(math.sign(-5), -1)
|
|
assert_equal(math.sign(0), 0)
|
|
end)
|
|
|
|
test("math.clamp", function()
|
|
assert_equal(math.clamp(5, 0, 3), 3)
|
|
assert_equal(math.clamp(-1, 0, 3), 0)
|
|
assert_equal(math.clamp(2, 0, 3), 2)
|
|
end)
|
|
|
|
test("math.lerp", function()
|
|
assert_close(math.lerp(0, 10, 0.5), 5)
|
|
assert_close(math.lerp(2, 8, 0.25), 3.5)
|
|
end)
|
|
|
|
test("math.smoothstep", function()
|
|
assert_close(math.smoothstep(0, 1, 0.5), 0.5)
|
|
assert_close(math.smoothstep(0, 10, 5), 0.5)
|
|
end)
|
|
|
|
test("math.map", function()
|
|
assert_close(math.map(5, 0, 10, 0, 100), 50)
|
|
assert_close(math.map(2, 0, 4, 10, 20), 15)
|
|
end)
|
|
|
|
test("math.round", function()
|
|
assert_equal(math.round(2.7), 3)
|
|
assert_equal(math.round(-2.7), -3)
|
|
assert_equal(math.round(2.3), 2)
|
|
end)
|
|
|
|
test("math.roundto", function()
|
|
assert_close(math.roundto(3.14159, 2), 3.14)
|
|
assert_close(math.roundto(123.456, 1), 123.5)
|
|
end)
|
|
|
|
test("math.normalize_angle", function()
|
|
assert_close(math.normalize_angle(math.pi * 2.5), math.pi * 0.5)
|
|
assert_close(math.normalize_angle(-math.pi * 2.5), -math.pi * 0.5)
|
|
end)
|
|
|
|
test("math.distance", function()
|
|
assert_close(math.distance(0, 0, 3, 4), 5)
|
|
assert_close(math.distance(1, 1, 4, 5), 5)
|
|
end)
|
|
|
|
test("math.factorial", function()
|
|
assert_equal(math.factorial(5), 120)
|
|
assert_equal(math.factorial(0), 1)
|
|
assert_equal(math.factorial(-1), nil)
|
|
end)
|
|
|
|
test("math.gcd", function()
|
|
assert_equal(math.gcd(48, 18), 6)
|
|
assert_equal(math.gcd(100, 25), 25)
|
|
end)
|
|
|
|
test("math.lcm", function()
|
|
assert_equal(math.lcm(4, 6), 12)
|
|
assert_equal(math.lcm(15, 20), 60)
|
|
end)
|
|
|
|
-- Random functions tests
|
|
test("math.randomf", function()
|
|
local r1 = math.randomf(0, 1)
|
|
local r2 = math.randomf(5, 10)
|
|
assert(r1 >= 0 and r1 < 1)
|
|
assert(r2 >= 5 and r2 < 10)
|
|
end)
|
|
|
|
test("math.randint", function()
|
|
local i1 = math.randint(1, 10)
|
|
local i2 = math.randint(50, 60)
|
|
assert(i1 >= 1 and i1 <= 10)
|
|
assert(i2 >= 50 and i2 <= 60)
|
|
end)
|
|
|
|
test("math.randboolean", function()
|
|
local b1 = math.randboolean()
|
|
local b2 = math.randboolean(0.8)
|
|
assert_equal(type(b1), "boolean")
|
|
assert_equal(type(b2), "boolean")
|
|
end)
|
|
|
|
-- Statistics tests
|
|
test("math.sum", function()
|
|
assert_equal(math.sum({1, 2, 3, 4, 5}), 15)
|
|
assert_equal(math.sum({10, 20, 30}), 60)
|
|
end)
|
|
|
|
test("math.mean", function()
|
|
assert_equal(math.mean({1, 2, 3, 4, 5}), 3)
|
|
assert_equal(math.mean({10, 20, 30}), 20)
|
|
end)
|
|
|
|
test("math.median", function()
|
|
assert_equal(math.median({1, 2, 3, 4, 5}), 3)
|
|
assert_equal(math.median({1, 2, 3, 4}), 2.5)
|
|
end)
|
|
|
|
test("math.variance", function()
|
|
assert_close(math.variance({1, 2, 3, 4, 5}), 2)
|
|
assert_close(math.variance({10, 10, 10}), 0)
|
|
end)
|
|
|
|
test("math.stdev", function()
|
|
assert_close(math.stdev({1, 2, 3, 4, 5}), math.sqrt(2))
|
|
assert_close(math.stdev({10, 10, 10}), 0)
|
|
end)
|
|
|
|
test("math.mode", function()
|
|
assert_equal(math.mode({1, 2, 2, 3}), 2)
|
|
assert_equal(math.mode({5, 5, 4, 4, 4}), 4)
|
|
end)
|
|
|
|
test("math.minmax", function()
|
|
local min1, max1 = math.minmax({1, 2, 3, 4, 5})
|
|
local min2, max2 = math.minmax({-5, 0, 10})
|
|
assert_equal(min1, 1)
|
|
assert_equal(max1, 5)
|
|
assert_equal(min2, -5)
|
|
assert_equal(max2, 10)
|
|
end)
|
|
|
|
-- 2D Vector tests
|
|
test("math.vec2.new", function()
|
|
local v1 = math.vec2.new(3, 4)
|
|
local v2 = math.vec2.new()
|
|
assert_equal(v1.x, 3)
|
|
assert_equal(v1.y, 4)
|
|
assert_equal(v2.x, 0)
|
|
assert_equal(v2.y, 0)
|
|
end)
|
|
|
|
test("math.vec2.add", function()
|
|
local v1 = math.vec2.new(3, 4)
|
|
local v2 = math.vec2.new(1, 2)
|
|
local result = math.vec2.add(v1, v2)
|
|
assert_equal(result.x, 4)
|
|
assert_equal(result.y, 6)
|
|
end)
|
|
|
|
test("math.vec2.sub", function()
|
|
local v1 = math.vec2.new(3, 4)
|
|
local v2 = math.vec2.new(1, 2)
|
|
local result = math.vec2.sub(v1, v2)
|
|
assert_equal(result.x, 2)
|
|
assert_equal(result.y, 2)
|
|
end)
|
|
|
|
test("math.vec2.mul", function()
|
|
local v1 = math.vec2.new(3, 4)
|
|
local result1 = math.vec2.mul(v1, 2)
|
|
local result2 = math.vec2.mul(v1, math.vec2.new(2, 3))
|
|
assert_equal(result1.x, 6)
|
|
assert_equal(result1.y, 8)
|
|
assert_equal(result2.x, 6)
|
|
assert_equal(result2.y, 12)
|
|
end)
|
|
|
|
test("math.vec2.dot", function()
|
|
local v1 = math.vec2.new(3, 4)
|
|
local v2 = math.vec2.new(1, 2)
|
|
assert_equal(math.vec2.dot(v1, v2), 11)
|
|
assert_equal(math.vec2.dot(math.vec2.new(1, 0), math.vec2.new(0, 1)), 0)
|
|
end)
|
|
|
|
test("math.vec2.length", function()
|
|
local v1 = math.vec2.new(3, 4)
|
|
local v2 = math.vec2.new(0, 5)
|
|
assert_close(math.vec2.length(v1), 5)
|
|
assert_close(math.vec2.length(v2), 5)
|
|
end)
|
|
|
|
test("math.vec2.distance", function()
|
|
local v1 = math.vec2.new(0, 0)
|
|
local v2 = math.vec2.new(3, 4)
|
|
assert_close(math.vec2.distance(v1, v2), 5)
|
|
assert_close(math.vec2.distance(math.vec2.new(1, 1), math.vec2.new(4, 5)), 5)
|
|
end)
|
|
|
|
test("math.vec2.normalize", function()
|
|
local v1 = math.vec2.new(3, 4)
|
|
local normalized = math.vec2.normalize(v1)
|
|
assert_close(math.vec2.length(normalized), 1)
|
|
assert_close(normalized.x, 0.6)
|
|
assert_close(normalized.y, 0.8)
|
|
end)
|
|
|
|
test("math.vec2.rotate", function()
|
|
local v1 = math.vec2.new(1, 0)
|
|
local rotated90 = math.vec2.rotate(v1, math.pi/2)
|
|
local rotated180 = math.vec2.rotate(v1, math.pi)
|
|
assert_close(rotated90.x, 0, 1e-10)
|
|
assert_close(rotated90.y, 1)
|
|
assert_close(rotated180.x, -1)
|
|
assert_close(rotated180.y, 0, 1e-10)
|
|
end)
|
|
|
|
-- 3D Vector tests
|
|
test("math.vec3.new", function()
|
|
local v1 = math.vec3.new(1, 2, 3)
|
|
local v2 = math.vec3.new()
|
|
assert_equal(v1.x, 1)
|
|
assert_equal(v1.y, 2)
|
|
assert_equal(v1.z, 3)
|
|
assert_equal(v2.x, 0)
|
|
assert_equal(v2.y, 0)
|
|
assert_equal(v2.z, 0)
|
|
end)
|
|
|
|
test("math.vec3.cross", function()
|
|
local v1 = math.vec3.new(1, 0, 0)
|
|
local v2 = math.vec3.new(0, 1, 0)
|
|
local cross = math.vec3.cross(v1, v2)
|
|
assert_equal(cross.x, 0)
|
|
assert_equal(cross.y, 0)
|
|
assert_equal(cross.z, 1)
|
|
end)
|
|
|
|
test("math.vec3.length", function()
|
|
local v1 = math.vec3.new(1, 2, 3)
|
|
local v2 = math.vec3.new(0, 0, 5)
|
|
assert_close(math.vec3.length(v1), math.sqrt(14))
|
|
assert_close(math.vec3.length(v2), 5)
|
|
end)
|
|
|
|
-- Matrix tests
|
|
test("math.mat2.det", function()
|
|
local m1 = math.mat2.new(1, 2, 3, 4)
|
|
local m2 = math.mat2.new(2, 0, 0, 3)
|
|
assert_equal(math.mat2.det(m1), -2)
|
|
assert_equal(math.mat2.det(m2), 6)
|
|
end)
|
|
|
|
test("math.mat2.mul", function()
|
|
local m1 = math.mat2.new(1, 2, 3, 4)
|
|
local m2 = math.mat2.new(2, 0, 1, 3)
|
|
local product = math.mat2.mul(m1, m2)
|
|
assert_equal(product[1][1], 4)
|
|
assert_equal(product[1][2], 6)
|
|
assert_equal(product[2][1], 10)
|
|
assert_equal(product[2][2], 12)
|
|
end)
|
|
|
|
test("math.mat2.rotation", function()
|
|
local rot90 = math.mat2.rotation(math.pi/2)
|
|
local rot180 = math.mat2.rotation(math.pi)
|
|
assert_close(rot90[1][1], 0, 1e-10)
|
|
assert_close(rot90[1][2], -1)
|
|
assert_close(rot180[1][1], -1)
|
|
assert_close(rot180[2][2], -1)
|
|
end)
|
|
|
|
test("math.mat3.transform_point", function()
|
|
local translation = math.mat3.translation(5, 10)
|
|
local point1 = {x = 1, y = 2}
|
|
local point2 = {x = 0, y = 0}
|
|
local t1 = math.mat3.transform_point(translation, point1)
|
|
local t2 = math.mat3.transform_point(translation, point2)
|
|
assert_equal(t1.x, 6)
|
|
assert_equal(t1.y, 12)
|
|
assert_equal(t2.x, 5)
|
|
assert_equal(t2.y, 10)
|
|
end)
|
|
|
|
test("math.mat3.det", function()
|
|
local identity = math.mat3.identity()
|
|
local scale = math.mat3.scale(2, 3)
|
|
assert_close(math.mat3.det(identity), 1)
|
|
assert_close(math.mat3.det(scale), 6)
|
|
end)
|
|
|
|
-- Geometry tests
|
|
test("math.geometry.triangle_area", function()
|
|
local area1 = math.geometry.triangle_area(0, 0, 4, 0, 0, 3)
|
|
local area2 = math.geometry.triangle_area(0, 0, 2, 0, 1, 2)
|
|
assert_close(area1, 6)
|
|
assert_close(area2, 2)
|
|
end)
|
|
|
|
test("math.geometry.point_in_triangle", function()
|
|
local inside1 = math.geometry.point_in_triangle(1, 1, 0, 0, 4, 0, 0, 3)
|
|
local inside2 = math.geometry.point_in_triangle(5, 5, 0, 0, 4, 0, 0, 3)
|
|
assert_equal(inside1, true)
|
|
assert_equal(inside2, false)
|
|
end)
|
|
|
|
test("math.geometry.line_intersect", function()
|
|
local intersects1, x1, y1 = math.geometry.line_intersect(0, 0, 2, 2, 0, 2, 2, 0)
|
|
local intersects2, x2, y2 = math.geometry.line_intersect(0, 0, 1, 1, 2, 2, 3, 3)
|
|
assert_equal(intersects1, true)
|
|
assert_close(x1, 1)
|
|
assert_close(y1, 1)
|
|
assert_equal(intersects2, false)
|
|
end)
|
|
|
|
test("math.geometry.closest_point_on_segment", function()
|
|
local x1, y1 = math.geometry.closest_point_on_segment(1, 3, 0, 0, 4, 0)
|
|
local x2, y2 = math.geometry.closest_point_on_segment(5, 1, 0, 0, 4, 0)
|
|
assert_close(x1, 1)
|
|
assert_close(y1, 0)
|
|
assert_close(x2, 4)
|
|
assert_close(y2, 0)
|
|
end)
|
|
|
|
-- Interpolation tests
|
|
test("math.interpolation.bezier", function()
|
|
local result1 = math.interpolation.bezier(0.5, 0, 1, 2, 3)
|
|
local result2 = math.interpolation.bezier(0, 0, 1, 2, 3)
|
|
assert_close(result1, 1.5)
|
|
assert_close(result2, 0)
|
|
end)
|
|
|
|
test("math.interpolation.quadratic_bezier", function()
|
|
local result1 = math.interpolation.quadratic_bezier(0.5, 0, 2, 4)
|
|
local result2 = math.interpolation.quadratic_bezier(1, 0, 2, 4)
|
|
assert_close(result1, 2)
|
|
assert_close(result2, 4)
|
|
end)
|
|
|
|
test("math.interpolation.smootherstep", function()
|
|
local result1 = math.interpolation.smootherstep(0, 1, 0.5)
|
|
local result2 = math.interpolation.smootherstep(0, 10, 5)
|
|
assert_close(result1, 0.5)
|
|
assert_close(result2, 0.5)
|
|
end)
|
|
|
|
test("math.interpolation.catmull_rom", function()
|
|
local result1 = math.interpolation.catmull_rom(0.5, 0, 1, 2, 3)
|
|
local result2 = math.interpolation.catmull_rom(0, 0, 1, 2, 3)
|
|
assert_close(result1, 1.5)
|
|
assert_close(result2, 1)
|
|
end)
|
|
|
|
summary()
|
|
test_exit()
|