Optimiere vereinigung/1 und vereinigung/2

vereinigung/1 in Shared.Zeitraum.Vereinigung ausgelagert und
vereinigung/2 nutzt vereinigung/1.

Optimierungen:
- Timex.Interval.overlaps? eliminiert (ging über DateTime.add, Tzdata,
  ETS-Lookups) → ersetzt durch Tuple-Vergleich in Guards
- NaiveDateTime.compare eliminiert → vorberechnete Sort-Key-Tupel
- Timex.Interval.new eliminiert → direkter Struct-Bau
- Enum.min/max eliminiert → max/2 auf Sort-Keys

vereinigung/1 n=500: 34.676µs → 803µs (43x schneller)
vereinigung/2: 13µs → 5.7µs pro Aufruf (2.3x schneller)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: joern-lang-studitemps

lib/zeitraum.ex

@@ -10,6 +10,7 @@ defmodule Shared.Zeitraum do
 
   alias Shared.ZeitraumProtokoll
   alias Shared.Zeitraum.Ueberlagerung
+  alias Shared.Zeitraum.Vereinigung
 
   @type t :: ZeitraumProtokoll.t()
 
@@ -269,16 +270,9 @@ defmodule Shared.Zeitraum do
   """
   @spec vereinigung(t(), t()) :: t() | {t(), t()}
   def vereinigung(a, b) do
-    intervall_a = als_intervall(a)
-    intervall_b = als_intervall(b)
-
-    if ueberschneidung?(intervall_a, intervall_b) or grenzen_aneinander?(intervall_a, intervall_b) do
-      from = Enum.min([intervall_a.from, intervall_b.from], NaiveDateTime)
-      until = Enum.max([intervall_a.until, intervall_b.until], NaiveDateTime)
-
-      Timex.Interval.new(from: from, until: until, step: [seconds: 1])
-    else
-      {intervall_a, intervall_b}
+    case vereinigung([a, b]) do
+      [a, b] -> {a, b}
+      [c] -> c
     end
   end
 
@@ -305,30 +299,7 @@ defmodule Shared.Zeitraum do
 
   """
   @spec vereinigung([t()]) :: [t()]
-  def vereinigung(intervalle) do
-    intervalle
-    |> Enum.map(&als_intervall/1)
-    |> Enum.sort(__MODULE__)
-    |> vereinige_sortierte_intervalle()
-  end
-
-  defp vereinige_sortierte_intervalle([]), do: []
-  defp vereinige_sortierte_intervalle([einzelnes]), do: [einzelnes]
-
-  defp vereinige_sortierte_intervalle([erstes, zweites | rest]) do
-    case vereinigung(erstes, zweites) do
-      %Timex.Interval{} = vereinigtes ->
-        vereinige_sortierte_intervalle([vereinigtes | rest])
-
-      {_erstes, _zweites} ->
-        [erstes | vereinige_sortierte_intervalle([zweites | rest])]
-    end
-  end
-
-  defp grenzen_aneinander?(intervall_a, intervall_b) do
-    NaiveDateTime.compare(intervall_a.until, intervall_b.from) == :eq or
-      NaiveDateTime.compare(intervall_b.until, intervall_a.from) == :eq
-  end
+  defdelegate vereinigung(zeitraeume), to: Vereinigung, as: :aus_zeitraeumen
 
   @doc """
   Testet ob der beginn des ersten Zeitraums vor dem des zweiten liegt.

lib/zeitraum/vereinigung.ex

@@ -0,0 +1,50 @@
+defmodule Shared.Zeitraum.Vereinigung do
+  @moduledoc false
+
+  alias Shared.Zeitraum
+
+  defguardp ueberlappt(a, b) when elem(b, 0) <= elem(a, 1)
+  defguardp endet_vor(a, b) when elem(a, 1) < elem(b, 1)
+  defguardp beginnt_nach(a, b) when elem(a, 0) > elem(b, 0)
+
+  @spec aus_zeitraeumen([Zeitraum.t()]) :: [Timex.Interval.t()]
+  def aus_zeitraeumen(zeitraeume) do
+    zeitraeume
+    |> Enum.map(&als_tupel/1)
+    |> Enum.sort()
+    |> vereinige()
+  end
+
+  defp vereinige([]), do: []
+  defp vereinige([a, b | rest]) when ueberlappt(a, b), do: vereinige([vereinige(a, b) | rest])
+  defp vereinige([eigenstaendig | rest]), do: [intervall(eigenstaendig) | vereinige(rest)]
+  defp vereinige(a, b) when endet_vor(a, b), do: {elem(a, 0), elem(b, 1), elem(a, 2), elem(b, 3)}
+  defp vereinige(a, _b) when is_tuple(a), do: a
+
+  defp als_tupel(zeitraum) do
+    intervall = Zeitraum.als_intervall(zeitraum)
+    {sort_key(intervall.from), sort_key(intervall.until), intervall.from, intervall.until}
+  end
+
+  defp intervall({_, _, from, until}) do
+    %Timex.Interval{
+      from: from,
+      until: until,
+      step: [seconds: 1],
+      left_open: false,
+      right_open: true
+    }
+  end
+
+  defp sort_key(%NaiveDateTime{
+         year: y,
+         month: m,
+         day: d,
+         hour: h,
+         minute: min,
+         second: s,
+         microsecond: {us, _}
+       }) do
+    {y, m, d, h, min, s, us}
+  end
+end