feat: ✨ add basic interpolation

Author: maxbarsukov

lib/algo/interpolation.ex

@@ -0,0 +1,17 @@
+defmodule InterpolationApp.Algo.Interpolation do
+  @moduledoc """
+  GenServer that prints new results when received
+  """
+
+  @doc """
+  Interpolates a value from given points.
+  """
+  @callback interpolate(points :: [tuple()], target_point :: number()) :: number()
+
+  @doc """
+  Interpolates values ​​from given points.
+  """
+  @callback interpolate(points :: [tuple()], target_points :: [number()]) :: [number()]
+
+  @callback points_enough?(points :: [tuple()]) :: boolean
+end

lib/algo/linear_interpolation.ex

@@ -0,0 +1,30 @@
+defmodule InterpolationApp.Algo.LinearInterpolation do
+  @moduledoc """
+  In mathematics, linear interpolation is a method of curve fitting using linear polynomials to construct
+  new data points within the range of a discrete set of known data points.
+  """
+
+  @behaviour InterpolationApp.Algo.Interpolation
+
+  def get_name, do: "Линейная интерполяция"
+
+  def get_enough_points_count, do: 2
+
+  @impl true
+  def points_enough?(points), do: length(points) >= get_enough_points_count()
+
+  @impl true
+  def interpolate(points, target_point) when not is_list(target_point) do
+    [{x0, y0}, {x1, y1}] = points
+
+    a = (y1 - y0) / (x1 - x0)
+    b = y0 - a * x0
+
+    {target_point, a * target_point + b}
+  end
+
+  @impl true
+  def interpolate(points, xs) when is_list(xs) do
+    Enum.map(xs, fn x -> interpolate(points, x) end)
+  end
+end

lib/cli/applier.ex

@@ -0,0 +1,50 @@
+defmodule InterpolationApp.CLI.Applier do
+  @moduledoc """
+  GenServer that applies input on interpolator
+  """
+
+  use GenServer
+
+  alias InterpolationApp.Utils.InputValidator
+
+  # Client API
+
+  def start_link(interpolator_pid) do
+    GenServer.start_link(__MODULE__, interpolator_pid, name: __MODULE__)
+  end
+
+  def apply_input(input) do
+    GenServer.cast(__MODULE__, {:apply_input, input})
+  end
+
+  # Server Callbacks
+
+  @impl true
+  def init(interpolator_pid) do
+    {:ok, {interpolator_pid, nil}}
+  end
+
+  @impl true
+  def handle_cast({:apply_input, input}, {interpolator_pid, prev_x}) do
+    {validation_status, validation_result} = InputValidator.validate_input(input)
+
+    if validation_status == :error do
+      IO.puts(validation_result)
+      {:noreply, {interpolator_pid, prev_x}}
+    else
+      process_new_point(validation_result, prev_x, interpolator_pid)
+    end
+  end
+
+  # Helper Functions
+
+  defp process_new_point({x, y}, prev_x, interpolator_pid) do
+    if prev_x == nil or prev_x < x do
+      GenServer.cast(interpolator_pid, {:add_point, {x, y}})
+      {:noreply, {interpolator_pid, x}}
+    else
+      IO.puts("Следующее значение X должно быть больше предыдущего (но #{x} < #{prev_x})")
+      {:noreply, {interpolator_pid, prev_x}}
+    end
+  end
+end

lib/cli/config_parser.ex

@@ -0,0 +1,87 @@
+defmodule InterpolationApp.CLI.ConfigParser do
+  @moduledoc """
+  Parses args for interpolation-app CLI
+  """
+
+  @methods ["linear", "lagrange2", "lagrange3", "newton"]
+
+  def parse_args(args) do
+    args
+    |> Enum.reduce(%{}, &parse_arg/2)
+    |> validate_args()
+  end
+
+  defp parse_arg("--method1=" <> method, acc) do
+    Map.put(acc, :method1, String.trim(method))
+  end
+
+  defp parse_arg("--method2=" <> method, acc) do
+    Map.put(acc, :method2, String.trim(method))
+  end
+
+  defp parse_arg("--step=" <> step, acc) do
+    Map.put(acc, :step, String.trim(step))
+  end
+
+  defp parse_arg("--accuracy=" <> accuracy, acc) do
+    Map.put(acc, :accuracy, String.trim(accuracy))
+  end
+
+  defp parse_arg(_, acc), do: acc
+
+  defp validate_args(%{method1: method1, method2: method2, step: step, accuracy: accuracy}) do
+    cond do
+      !valid_method?(method1) ->
+        {:error,
+         "Неправильный method1: #{method1}. Должен быть один из [#{Enum.join(@methods, ", ")}]."}
+
+      !valid_method?(method2) ->
+        {:error,
+         "Неправильный method2: #{method2}. Должен быть один из [#{Enum.join(@methods, ", ")}]."}
+
+      !valid_step?(step) ->
+        {:error,
+         "Неправильный step: #{step}. Должен быть положительным числом (например: 0.1, 1, 10, ...)."}
+
+      !valid_accuracy?(accuracy) ->
+        {:error, "Неправильный accuracy: #{accuracy}. Должен быть положительным целым числом."}
+
+      true ->
+        {:ok,
+         %{
+           method1: module_from_method(method1),
+           method2: module_from_method(method2),
+           step: elem(Float.parse(step), 0),
+           accuracy: elem(Integer.parse(accuracy), 0)
+         }}
+    end
+  end
+
+  defp validate_args(%{method1: method1, method2: method2, step: step}) do
+    validate_args(%{method1: method1, method2: method2, step: step, accuracy: "3"})
+  end
+
+  defp validate_args(_) do
+    {:error, "Ошибка! Обязательные аргументы: --method1=, --method2=, --step="}
+  end
+
+  defp valid_method?(method), do: method in @methods
+
+  defp valid_step?(step) do
+    case Float.parse(step) do
+      {value, ""} -> value > 0
+      _ -> false
+    end
+  end
+
+  defp valid_accuracy?(accuracy) do
+    case Integer.parse(accuracy) do
+      {value, ""} -> value > 0
+      _ -> false
+    end
+  end
+
+  defp module_from_method(method) do
+    Module.concat(["InterpolationApp", "Algo", "#{String.capitalize(method)}Interpolation"])
+  end
+end

lib/cli/interpolator.ex

@@ -0,0 +1,48 @@
+defmodule InterpolationApp.CLI.Interpolator do
+  @moduledoc """
+  GenServer that interpolates values
+  """
+
+  use GenServer
+
+  alias InterpolationApp.Utils.PointGenerator
+
+  # Client API
+
+  def start_link(config, printer_pid) do
+    GenServer.start_link(__MODULE__, {config, printer_pid}, name: __MODULE__)
+  end
+
+  def add_point(point) do
+    GenServer.cast(__MODULE__, {:add_point, point})
+  end
+
+  # Server Callbacks
+
+  @impl true
+  def init({config, printer_pid}) do
+    {:ok, {[], config, printer_pid}}
+  end
+
+  @impl true
+  def handle_cast({:add_point, point}, {points, config, printer_pid}) do
+    points = Enum.reverse([point | Enum.reverse(points)])
+    methods = Enum.uniq([config.method1, config.method2])
+
+    Enum.each(methods, fn method ->
+      if method.points_enough?(points) do
+        limit = method.get_enough_points_count()
+        interpolation_points = Enum.slice(points, -limit, limit)
+        generated_points = PointGenerator.generate(interpolation_points, config.step)
+
+        GenServer.cast(printer_pid, {
+          :print,
+          method,
+          method.interpolate(interpolation_points, generated_points)
+        })
+      end
+    end)
+
+    {:noreply, {points, config, printer_pid}}
+  end
+end

lib/cli/printer.ex

@@ -0,0 +1,57 @@
+defmodule InterpolationApp.CLI.Printer do
+  @moduledoc """
+  GenServer that prints new results when received
+  """
+
+  use GenServer
+
+  # Client API
+
+  def start_link(config) do
+    GenServer.start_link(__MODULE__, config, name: __MODULE__)
+  end
+
+  def print(method, result) do
+    GenServer.cast(__MODULE__, {:print, method, result})
+  end
+
+  # Server Callbacks
+
+  @impl true
+  def init(config) do
+    {:ok, config}
+  end
+
+  @impl true
+  def handle_cast({:print, method, result}, config) do
+    print_result(method, result, config.step, config.accuracy)
+    {:noreply, config}
+  end
+
+  # Helper Functions
+
+  defp print_result(method, result, step, accuracy) do
+    {first_x, _} = List.first(result)
+
+    IO.puts(
+      "#{method.get_name()} (идем от точки из введенных #{first_x} с шагом #{step}, покрывая все введенные X)"
+    )
+
+    print_line(result, accuracy)
+    IO.write("\n")
+  end
+
+  defp print_line(result, accuracy) do
+    format_string = String.duplicate("~s ", length(result)) <> "~n"
+
+    Enum.each([0, 1], fn n ->
+      :io.format(
+        format_string,
+        Enum.map(
+          result,
+          &String.pad_trailing(:erlang.float_to_binary(elem(&1, n), decimals: accuracy), 7)
+        )
+      )
+    end)
+  end
+end

lib/cli/repl.ex

@@ -0,0 +1,40 @@
+defmodule InterpolationApp.CLI.Repl do
+  @moduledoc """
+  Read-Eval-Print-Loop
+  """
+
+  alias InterpolationApp.CLI.{Applier, Interpolator, Printer}
+
+  def start(config) do
+    IO.puts("Введите 'quit', чтобы закончить ввод.")
+    IO.puts("Введите узлы интерполяции:")
+
+    {:ok, printer_pid} = Printer.start_link(config)
+    {:ok, interpolator_pid} = Interpolator.start_link(config, printer_pid)
+    {:ok, applier_pid} = Applier.start_link(interpolator_pid)
+
+    # spawn(fn -> loop(applier_pid) end)
+    loop(applier_pid)
+  end
+
+  defp loop(applier_pid) do
+    :io.setopts(:standard_io, active: true)
+    input = IO.gets("")
+
+    if input == :eof or String.trim(input) == "quit" do
+      IO.puts("\nСпасибо за использование программы!\n")
+
+      IO.puts("""
+            |\      _,,,---,,_
+      ZZZzz /,`.-'`'    -.  ;-;;,_
+          |,4-  ) )-,_. ,\ (  `'-'
+          '---''(_/--'  `-'\_)
+      """)
+
+      System.halt()
+    end
+
+    GenServer.cast(applier_pid, {:apply_input, String.trim(input)})
+    loop(applier_pid)
+  end
+end

lib/main.ex

@@ -3,16 +3,38 @@ defmodule InterpolationApp.Main do
   Application entry point
   """
 
+  alias InterpolationApp.CLI.{ConfigParser, Repl}
+
   @spec main([String.t()]) :: any()
   def main(args \\ []) do
-    args
-    |> parse_args()
-    |> IO.puts()
+    if Enum.member?(["--help", "-h"], List.first(args)) do
+      IO.puts(help())
+      System.halt()
+    end
+
+    case ConfigParser.parse_args(args) do
+      {:ok, config} ->
+        Repl.start(config)
+
+      {:error, message} ->
+        IO.puts(
+          "Неверный формат запуска!\n\n#{message}\nЧтобы получить помощь, запустите программу с флагом '--help'"
+        )
+    end
   end
 
-  defp parse_args(args) do
-    {opts, word, _} = args |> OptionParser.parse(switches: [upcase: :boolean])
+  defp help do
+    """
+    usage: interpolation-app [options] --method1=<method> --method2=<method> --step=<step>
+    options:
+      -h, --help              Prints this message
+      --accuracy=<accuracy>   Set printing accuracy
 
-    {opts, List.to_string(word)}
+    methods:
+      * linear
+      * lagrange2
+      * lagrange3
+      * newton
+    """
   end
 end