-- input: real number
-- output: round to the nearest integer number.
--         In case number ends in 0.5 it is rounded up.
function round(x)
  return math.floor(x + 0.5)
end

-- input: string
-- output: string with zeros added on the left, until reaching the desired length
function padding_on_left(s, length)
  local ans = s
  local n_fill = length - string.len(s)
  if (n_fill > 0) then
    ans = string.rep('0', n_fill) .. ans
  end
  return ans
end

-- input: positive integer number
-- output: string containing binary representation of the input
function binary(num)
    local ans = ''
    while (num > 0) do
        remainder = num%2
        ans = tostring(remainder) .. ans 
        num = math.tointeger((num-remainder)/2)
    end
    return ans
end

-- input: real number
-- output: list of strings containing the three elements of its representation 
--         as IEEEE 754 floating point
function components_ieee754(number)
  -- first reduce the problem to working with a 
  -- nonzero positive number
  local sign = 1
  if (number == 0) then
    return string.rep('0', 1), string.rep('0', 8), string.rep('0', 23)
  elseif (number < 0) then
    number = -number
    sign = -1
  end
  -- handle the inputs that are too large 
  -- pending
  
  -- handle the inputs that are too small
  -- pending 
  
  -- =====================
  -- === regular cases ===
  -- =====================
  -- compute mantissa and exponent
  local bias = 127
  local mantissa, exponent = math.frexp(number) -- this mantissa belongs to [0.5, 1)
  
  -- to simplify the problem, we convert and round the mantissa 
  -- to an integer number less than 2^24 and reformat the previous exponent
  mantissa = round(math.ldexp(mantissa, 24))
  exponent = exponent - 1
  mantissa_bin = binary(mantissa)
  exponent_bin = binary(bias + exponent)
  exponent_bin = padding_on_left(exponent_bin, 8)
  
  -- we set the first bit, according to sign
  local ans_sign = ''
  if (sign == 1) then 
    ans_sign = '0'
  else
    ans_sign = '1'
  end
  -- 8 bits for exponent + 23 bits for mantissa
  -- ans = ans .. exponent_bin .. string.sub(mantissa_bin, 2)
  return ans_sign, exponent_bin, string.sub(mantissa_bin, 2)
end

function num_to_ieee754(num)
  local s_sign, s_exponent, s_mantissa = components_ieee754(num)
  return tonumber(s_sign .. s_exponent .. s_mantissa)
end

-- ===============================================================
-- ===============================================================
-- some tests
testing_cases = {0, 
  0.121, 
  222, 
  -123.633, 
  0.145, 
  0.1,
  1079194419.000,
  1081711002.000
}

for i=1,#testing_cases do
  print('testing number: ' .. tostring(testing_cases[i]))
  print(components_ieee754(testing_cases[i]))
  print(num_to_ieee754(testing_cases[i]))
  print('\n')
end