Fastest method of sorting an element into an array in ascending order? [ANSWERED]

One easy way would be with an insert function that just cuts out an extra line of code each time you want to call. Insert the number into the table, then sort the table.

local tbl = {1, 1, 2, 3, 5, 8, 13, 21, 34}

function insert(num)
  table.insert(tbl, num)
  table.sort(tbl)
end

table.foreach(tbl, print)
insert(4)
insert(69)
insert(9)
table.foreach(tbl, print)

So I ended up using a sort of iterative binary sort algorithm that best suits my needs. The function will compare the value to the median between the lowest and highest points on the table that the value could possibly be between. Every iteration the range is adjusted accordingly.

In the event that the number being sorted is compared to an equal value, the function will treat it as though the number being sorted is larger. This is intended, because I wrote this code to function inside my own 'Task Executer'. The Task Executer is a class which sequentially calls a list of functions, ordered by priority. The elements in the code below simulate that priority. I wanted consistent behavior in the event that several functions are sorted under the same priority, so the most recently sorted function will execute last.

I also replaced some library functions with my own code to improve efficiency. I plan on using my Task Executer for a fire spreading mechanic in my survival game, along with several GUI animations, so efficiency is very important to me since this code will get plenty of action.

CODE:

local arr = {1, 1, 2, 3, 5, 8, 13, 21, 34}

local function sort(value)

    local low = 0   --The lowest index the value is between.
    local high = #arr + 1   --The highest index the value is between.
    local pivot --The median element between low and high, rounded down.

    while high - low ~= 1 do    --When range is equal to 1, there are no more elements between low and high, so the value must fit in-between.

        pivot = (low + high)/2; pivot = pivot - pivot % 1   --Calculate the pivot. 

        if value < arr[pivot] then  --If value is less than element at index 'pivot', then set high to pivot
            high = pivot
        else    --If value is greater than or equal to element at index 'pivot', then set low to pivot. This will move the new value behind any recurring elements.
            low = pivot
        end     
    end

    for index = #arr + 1, high + 1, -1 do
        arr[index] = arr[index - 1] --Shift existing elements after index 'high' up one
    end; arr[high] = value  --Insert value at index 'high'

    print("SORTING VALUE " .. value .. " :", unpack(arr))

end

print("ORIGINAL:", unpack(arr))
sort(4)
sort(4)
sort(8)
sort(0)
sort(34)
sort(93)

OUTPUT:

ORIGINAL: 1 1 2 3 5 8 13 21 34
SORTING VALUE 4: 1 1 2 3 4 5 8 13 21 34
SORTING VALUE 4: 1 1 2 3 4 4 5 8 13 21 34
SORTING VALUE 8: 1 1 2 3 4 4 5 8 8 13 21 34
SORTING VALUE 0: 0 1 1 2 3 4 4 5 8 8 13 21 34
SORTING VALUE 34: 0 1 1 2 3 4 4 5 8 8 13 21 34 34
SORTING VALUE 93: 0 1 1 2 3 4 4 5 8 8 13 21 34 34 93

I think there's still some minimal room for improvement with optimizations, but this is probably good enough for now. Thanks for the help and resources guys!