Untitled notebook

Section

path = "/Users/depebul/Library/Application Support/livebook/autosaved/2025_05_19/14_53_zgww/files/AirlyData-ALL-50k.csv"
lines = File.read!(path) |> String.split("\n", trim: true)
IO.puts(length(lines))

defmodule Modulek do
  def readline(line) do
    [datetime_str, pollution_type, pollution_level_str, station_id_str, station_name, location_str] =
      line |> String.split(";")
    {{year, month, day}, {hour, minute, second}} =
      datetime_str
      |> String.slice(0..18) # Ucinamy ".000Z"
      |> String.split(["-", "T", ":"])
      |> Enum.map(&String.to_integer/1)
      |> (fn [y, m, d, h, min, s] -> {{y, m, d}, {h, min, s}} end).()
    location =
      location_str
      |> String.split(",")
      |> Enum.map(&String.to_float/1)
      |> List.to_tuple()
    %{
      :datetime => {{year, month, day}, {hour, minute, second}},
      :pollutionType => pollution_type,
      :pollutionLevel => String.to_float(pollution_level_str),
      :stationId => String.to_integer(station_id_str),
      :stationName => station_name,
      :location => location
    }
  end
   def identify_stations(parsed_data) do
    Enum.uniq_by(parsed_data, fn entry ->
      {entry.stationId, entry.stationName}
    end)
    |> Enum.map(fn entry ->
      %{
        :stationId => entry.stationId,
        :stationName => entry.stationName,
        :location => entry.location
      }
    end)
  end
end

parsed_data = Enum.map(lines, &Modulek.readline/1)

IO.puts("\nLiczba sparsowanych wpisów: #{length(parsed_data)}")
IO.inspect(Enum.at(parsed_data, 0), label: "Pierwszy sparsowany wpis") # Wyświetl pierwszy wpis

unique_stations = Modulek.identify_stations(parsed_data)
num_unique_stations = length(unique_stations)
IO.puts("\nLiczba unikalnych stacji pomiarowych: #{num_unique_stations}")
IO.inspect(Enum.at(unique_stations, 0), label: "Pierwsza unikalna stacja")
IO.inspect(unique_stations)

Code.append_path("/Users/depebul/Projects/Github/erlang_elixir/lab4/_build/default/lib/lab4/ebin")
Application.start(:lab4)
:pollution_gen_server.create_monitor()

defmodule StationLoader do
  def load_stations(stations) do
    stations
    |> Enum.map(fn station ->
      station_name = "#{station.stationId} #{station.stationName}"
      IO.inspect(station_name, label: "Station name")
      :pollution_gen_server.add_station(station_name, station.location)
    end)
  end
end

:timer.tc(StationLoader, :load_stations, [unique_stations]) |> elem(0) |> Kernel./(1_000_000) |> Float.round(6)

defmodule DataLoader do
  def load_data(data) do
    data
    |> Enum.map(&(:pollution_gen_server.add_value(&1.location, &1.datetime, &1.pollutionType, &1.pollutionLevel)))
  end
end

:timer.tc(DataLoader, :load_data, [parsed_data]) |> elem(0)|> Kernel./(1_000_000) |> Float.round(6)

defmodule DataAnalyzer do
  def analyze_get_station_min() do
    :pollution_gen_server.get_station_min("9910 Polska, Kraków, Studencka", "PM10")
  end
  def analyze_get_daily_mean() do
    :pollution_gen_server.get_daily_mean("PM25", {2024, 2, 10})
  end
end

{time1, result1} = :timer.tc(DataAnalyzer, :analyze_get_station_min, [])
{time2, result2} = :timer.tc(DataAnalyzer, :analyze_get_daily_mean, [])
IO.puts("Execution time for get_station_min: #{time1 |> Kernel./(1_000_000) |> Float.round(6) } seconds")
IO.puts("Execution time for get_daily_mean: #{time2 |> Kernel./(1_000_000) |> Float.round(6)  } seconds")