Is there a simpler way than to pass a 40-object table? - lua

Question

I'm running these requests for numbers with five sub-cases which have four sub-cases each. There are over 200 of these cases, of which just one is shown below, so it would be several thousand lines of code. (This is example code, the numbers would not all be the same, of course.)
elseif case1 then
if u <= 0 then if w == 0 then return B(2,3), B(3,4)
elseif w == 1 then return B(2,3), B(3,4)
elseif w == 2 then return B(2,3), B(3,4)
elseif w >= 3 then return B(2,3), B(3,4)
elseif if u == 1 then return LimitCheck(if w == 0 then return B(2,3), B(3,4)
elseif w == 1 then return B(2,3), B(3,4)
elseif w == 2 then return B(2,3), B(3,4)
elseif w >= 3 then return B(2,3), B(3,4)
elseif if u == 2 then return LimitCheck(if w == 0 then return B(2,3), B(3,4)
elseif w == 1 then return B(2,3), B(3,4)
elseif w == 2 then return B(2,3), B(3,4)
elseif w >= 3 then return B(2,3), B(3,4)
elseif if u == 3 then return LimitCheck(if w == 0 then return B(2,3), B(3,4)
elseif w == 1 then return B(2,3), B(3,4)
elseif w == 2 then return B(2,3), B(3,4)
elseif w >= 3 then return B(2,3), B(3,4)
elseif if u == 4 then return LimitCheck(if w == 0 then return B(2,3), B(3,4)
elseif w == 1 then return B(2,3), B(3,4)
elseif w == 2 then return B(2,3), B(3,4)
elseif w >= 3 then return B(2,3), B(3,4)
I thought I'd be clever and compartmentalize the code that repeats, let sub-functions take apart the cases:
local function LimitCheck(arg)
if w <= 0 then return arg[1], arg[2]
elseif w == 1 then return arg[3], arg[4]
elseif w == 2 then return arg[5], arg[6]
elseif w >= 3 then return arg[7], arg[8]
end
end
local function Limits(arg)
if u == 0 then return LimitCheck({arg[1],arg[2],arg[3],arg[4],arg[5],arg[6],arg[7],arg[8],})
elseif u == 1 then return LimitCheck({arg[9],arg[10],arg[11],arg[12],arg[13],arg[14],arg[15],arg[16],})
elseif u == 2 then return LimitCheck({arg[17],arg[18],arg[19],arg[20],arg[21],arg[22],arg[23],arg[24],})
elseif u == 3 then return LimitCheck({arg[25],arg[26],arg[27],arg[28],arg[29],arg[30],arg[31],arg[32],})
elseif u == 4 then return LimitCheck({arg[33],arg[34],arg[35],arg[36],arg[37],arg[38],arg[39],arg[40]})
end
end
And then have the main function return what it needs to know in one bulk:
elseif case1 then
return Limits({B(5,6),B(7,8), B(5,6),B(5,6), B(5,6),B(5,6), B(5,6),B(5,6),
B(5,6),B(5,6), B(5,6),B(5,6), B(5,6),B(5,6), B(5,6),B(5,6),
B(5,6),B(5,6), B(5,6),B(5,6), B(5,6),B(5,6), B(5,6),B(5,6),
B(5,6),B(5,6), B(5,6),B(5,6), B(5,6),B(5,6), B(5,6),B(5,6),
B(5,6),B(5,6), B(5,6),B(5,6), B(5,6),B(5,6), B(5,6),B(5,6)})
Problem is, this is a 40-entry table object that is passed every time, quite a bulky undertaking for a request that may happen 100 times a second. And it returns a bunch of stuff that isn't used.
I wonder if there is a resource-saving way to do this.

Answer 1

Here's an example of how to do this using a lookup table.
You can hardcode it or build it from code if the structure allows it.
local LUT = {
[0] = {
[0] = "a",
[1] = "b",
[2] = "c",
[3] = "d",
},
[1] = {
[0] = "e",
[1] = "f",
[2] = "g",
[3] = "h",
},
[2] = {
[0] = "i",
[1] = "j",
[2] = "k",
[3] = "l",
},
[3] = {
[0] = "m",
[1] = "n",
[2] = "o",
[3] = "p",
},
[4] = {
[0] = "q",
[1] = "r",
[2] = "s",
[3] = "t",
},
}
function lookup(u, w)
-- we only accept u <= 5
if math.type(u) ~= "integer" or u > 4
-- and w >= 0
or math.type(w) ~= "integer" or w < 0 then
return
end
return LUT[math.max(0, u)][math.min(3, w)]
end
print(lookup(-5, 3))