Calculating average of seconds in list of maps Elixir

I have this sample data

[
%{  check_in_time: 60,
    imaging_time: 180,
    lab_time: 120,
    vital_time: 60,
    pharmacy_time: 100
},
%{
    check_in_time: 20,
    imaging_time: 380,
    lab_time: 10,
    vital_time: 60,
    pharmacy_time: 200
}
]

where all these entities are presenting time in seconds, What I want to achieve here is:

calculate the average of these times such as each entry presents, a Patients details, and how much time a patient spent in the hospital, but now I need to calculate the grand average of these times, to show the average waiting time for a patient considering all patient's details.

what I did.

    items
    |> Enum.reduce(
      %{
        check_in_time: 0,
        imaging_time: 0,
        lab_time: 0,
        pharmacy_time: 0,
        vital_time: 0
      },
      fn %{
           check_in_time: check_in_time,
           imaging_time: imaging_time,
           lab_time: lab_time,
           pharmacy_time: pharmacy_time,
           vital_time: vital_time
         },
         acc ->
        %{
          check_in_time: acc.check_in_time + check_in_time,
          imaging_time: acc.imaging_time + imaging_time,
          lab_time: acc.lab_time + lab_time,
          pharmacy_time: acc.pharmacy_time + pharmacy_time,
          vital_time: acc.vital_time + vital_time
        }
      end
    )
    |> sum_average()
  end

  defp sum_average(%{
         check_in_time: check_in_time,
         imaging_time: imaging_time,
         lab_time: lab_time,
         pharmacy_time: pharmacy_time,
         vital_time: vital_time
       }) do
    (check_in_time + imaging_time + lab_time + pharmacy_time + vital_time) / 5
  end

I did some R&D and learned this is not the right way to do it. Please guide me on the right way of calculating the average time value in seconds, with the above data. PS: values for those keys can be nil as well.

Any help would be wonderful thank you.

Update: the expected formula and result would be.

    (60 + 20) / 2 (number of values) = 40
    (180 + 380) / 2 = 280
    (120 + 10) / 2 = 65
    (60 + 60) / 2 = 60
    (100 + 200) / 2 = 150

    (40 + 280 + 65 + 60 + 150) / 5 (number of values) = 119

I think you can do this fairly simply using Map.values/1 and Enum.sum/1, e.g.

input = [
  %{  check_in_time: 60, 
    imaging_time: 180,
    lab_time: 120,
    vital_time: 60,
    pharmacy_time: 100
  },
  %{
    check_in_time: 20,
    imaging_time: 380,
    lab_time: 10,
    vital_time: 60,
    pharmacy_time: 200
  }
]

times = input |> Enum.map(fn x -> Map.values(x) end) |> List.flatten() |> Enum.reject(&is_nil/1)
cnt = length(times)
sum = Enum.sum(times)

average = sum / cnt
# 119.0

I don't think there's any need to maintain a complicated map of accumulators. Performance is a bit better if you enumerate the list yourself once, e.g.

{sum, cnt} = input |> Enum.reduce({0, 0}, fn x, {sum, cnt} ->
  vals = x |> Map.values() |> Enum.reject(&is_nil/1)
  sum = sum + Enum.sum(vals)
  cnt = cnt + length(vals)
  {sum, cnt}
end)


average = sum / cnt

Other refinements are possible, but both options are reasonably fast: running the first option 10 million (!) times took 1033ms, while the second option took 773m. So I would focus on a solution with the greatest clarity and ease of maintenance, and I think that means using built-in functions over home-rolled ones whenever possible.

The following code just does reduce() by hand so that on the final iteration of the list, i.e. when the list is empty, the code can calculate the average:

defmodule My do
  def items do
    [
      %{  check_in_time: 60,
          imaging_time: 180,
          lab_time: 120,
          vital_time: 60,
          pharmacy_time: 100
      },
      %{
          check_in_time: 20,
          imaging_time: 380,
          lab_time: 10,
          vital_time: 60,
          pharmacy_time: 200
      }
    ]
  end
  
  //Public interface:
  def get_average(patients) do
    get_average(patients, [0,0,0,0,0,0])
  end 

  //Private helper function:
  defp get_average([], [cit, it, lt, pt, vt, count]) do
    patients_avg = (cit + it + lt + pt + vt)/count
    _category_avg = patients_avg/5
  end
  defp get_average([%{
    check_in_time: check_in_time,
    imaging_time: imaging_time,
    lab_time: lab_time,
    vital_time: vital_time,
    pharmacy_time: pharmacy_time} | patients], 
    [cit, it, lt, vt, pt, count] ) do

      get_average(patients, 
        [
          cit + if is_nil(check_in_time) do 0 else check_in_time end,
          it + if is_nil(imaging_time) do 0 else imaging_time end,
          lt + if is_nil(lab_time) do 0 else lab_time end,
          vt + if is_nil(vital_time) do 0 else vital_time end,
          pt + if is_nil(pharmacy_time) do 0 else pharmacy_time end,
          count + 1
        ]
      ) 
  end
end

In iex:

/elixir_programs% iex a.ex
Erlang/OTP 24 [erts-12.3.2] [source] [64-bit] [smp:8:8] [ds:8:8:10] [async-threads:1]

Interactive Elixir (1.14.4) - press Ctrl+C to exit (type h() ENTER for help)


iex(1)> items = My.items()
[
  %{
    check_in_time: 60,
    imaging_time: 180,
    lab_time: 120,
    pharmacy_time: 100,
    vital_time: 60
  },
  %{
    check_in_time: 20,
    imaging_time: 380,
    lab_time: 10,
    pharmacy_time: 200,
    vital_time: 60
  }
]
iex(2)> My.get_average(items)
119.0

The if is_nil() statements can be changed to the shorter but more cryptic:

      cit + (check_in_time || 0),
      it + (imaging_time || 0),
      lt + (lab_time || 0),
      vt + (vital_time || 0),
      pt + (pharmacy_time || 0),

But, you might want to consider using is_number() because if check_in_time is "a", then || will return "a" not 0--as will is_nil().