feat: ✨ implement interpolation algorithms

Author: maxbarsukov

lib/algo/interpolation.ex

@@ -13,5 +13,25 @@ defmodule InterpolationApp.Algo.Interpolation do
   """
   @callback interpolate(points :: [tuple()], target_points :: [number()]) :: [number()]
 
-  @callback points_enough?(points :: [tuple()]) :: boolean
+  @callback get_name() :: binary()
+
+  @callback get_enough_points_count() :: number()
+
+  @callback need_concrete_number_of_points?() :: boolean()
+
+  @callback points_enough?(points :: [tuple()]) :: boolean()
+
+  defmacro __using__(_) do
+    quote do
+      @behaviour InterpolationApp.Algo.Interpolation
+
+      @impl true
+      def points_enough?(points), do: length(points) >= get_enough_points_count()
+
+      @impl true
+      def interpolate(points, xs) when is_list(xs) do
+        Enum.map(xs, fn x -> interpolate(points, x) end)
+      end
+    end
+  end
 end

lib/algo/lagrange3_interpolation.ex

@@ -0,0 +1,29 @@
+defmodule InterpolationApp.Algo.Lagrange3Interpolation do
+  @moduledoc """
+  In numerical analysis, the Lagrange interpolating polynomial is the
+  unique polynomial of lowest degree that interpolates a given set of data.
+  """
+
+  use InterpolationApp.Algo.Interpolation
+
+  @impl true
+  def get_name, do: "Интерполяционный многочлен Лагранжа для 3 точек"
+
+  @impl true
+  def get_enough_points_count, do: 3
+
+  @impl true
+  def need_concrete_number_of_points?, do: true
+
+  @impl true
+  def interpolate(points, x) when not is_list(x) do
+    [{x0, y0}, {x1, y1}, {x2, y2}] = points
+
+    y =
+      y0 * ((x - x1) * (x - x2)) / ((x0 - x1) * (x0 - x2)) +
+        y1 * ((x - x0) * (x - x2)) / ((x1 - x0) * (x1 - x2)) +
+        y2 * ((x - x0) * (x - x1)) / ((x2 - x0) * (x2 - x1))
+
+    {x, y}
+  end
+end

lib/algo/lagrange4_interpolation.ex

@@ -0,0 +1,30 @@
+defmodule InterpolationApp.Algo.Lagrange4Interpolation do
+  @moduledoc """
+  In numerical analysis, the Lagrange interpolating polynomial is the
+  unique polynomial of lowest degree that interpolates a given set of data.
+  """
+
+  use InterpolationApp.Algo.Interpolation
+
+  @impl true
+  def get_name, do: "Интерполяционный многочлен Лагранжа для 4 точек"
+
+  @impl true
+  def get_enough_points_count, do: 4
+
+  @impl true
+  def need_concrete_number_of_points?, do: true
+
+  @impl true
+  def interpolate(points, x) when not is_list(x) do
+    [{x0, y0}, {x1, y1}, {x2, y2}, {x3, y3}] = points
+
+    y =
+      y0 * ((x - x1) * (x - x2) * (x - x3)) / ((x0 - x1) * (x0 - x2) * (x0 - x3)) +
+        y1 * ((x - x0) * (x - x2) * (x - x3)) / ((x1 - x0) * (x1 - x2) * (x1 - x3)) +
+        y2 * ((x - x0) * (x - x1) * (x - x3)) / ((x2 - x0) * (x2 - x1) * (x2 - x3)) +
+        y3 * ((x - x0) * (x - x1) * (x - x2)) / ((x3 - x0) * (x3 - x1) * (x3 - x2))
+
+    {x, y}
+  end
+end

lib/algo/linear_interpolation.ex

@@ -4,27 +4,24 @@ defmodule InterpolationApp.Algo.LinearInterpolation do
   new data points within the range of a discrete set of known data points.
   """
 
-  @behaviour InterpolationApp.Algo.Interpolation
+  use InterpolationApp.Algo.Interpolation
 
+  @impl true
   def get_name, do: "Линейная интерполяция"
 
+  @impl true
   def get_enough_points_count, do: 2
 
   @impl true
-  def points_enough?(points), do: length(points) >= get_enough_points_count()
+  def need_concrete_number_of_points?, do: true
 
   @impl true
-  def interpolate(points, target_point) when not is_list(target_point) do
+  def interpolate(points, x) when not is_list(x) 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)
+    {x, a * x + b}
   end
 end

lib/algo/newton_interpolation.ex

@@ -0,0 +1,55 @@
+defmodule InterpolationApp.Algo.NewtonInterpolation do
+  @moduledoc """
+  In the mathematical field of numerical analysis, a Newton polynomial, named after its inventor
+  Isaac Newton, is an interpolation polynomial for a given set of data points.
+  """
+
+  use InterpolationApp.Algo.Interpolation
+
+  @impl true
+  def get_name, do: "Интерполяция по Ньютону"
+
+  @impl true
+  def get_enough_points_count, do: 2
+
+  @impl true
+  def need_concrete_number_of_points?, do: false
+
+  @impl true
+  def interpolate(points, x) when not is_list(x) do
+    {x, points |> divided_differences |> evaluate_polynomial(points, x)}
+  end
+
+  defp divided_differences(points) do
+    n = length(points)
+    xs = Enum.map(points, fn {x, _} -> x end)
+    ys = Enum.map(points, fn {_, y} -> y end)
+
+    Enum.reduce(1..(n - 1), [ys], fn i, acc ->
+      prev_diffs = hd(acc)
+
+      diffs =
+        Enum.map(0..(n - i - 1), fn j ->
+          (Enum.at(prev_diffs, j + 1) - Enum.at(prev_diffs, j)) /
+            (Enum.at(xs, j + i) - Enum.at(xs, j))
+        end)
+
+      [diffs | acc]
+    end)
+    |> Enum.reverse()
+    |> Enum.map(&List.first/1)
+  end
+
+  defp evaluate_polynomial(coeffs, points, x) do
+    xs = Enum.map(points, fn {x, _} -> x end)
+
+    Enum.reduce(Enum.with_index(coeffs), 0, fn {coeff, i}, acc ->
+      term =
+        Enum.reduce(0..(i - 1), 1, fn j, prod ->
+          prod * (x - Enum.at(xs, j))
+        end)
+
+      acc + coeff * term
+    end)
+  end
+end