Add shortcut atoms for float dtypes

It adds `:f32` and `:f64` as shortcuts/aliases for the float dtypes.

This is related to #739

lib/explorer/series.ex

@@ -11,6 +11,7 @@ defmodule Explorer.Series do
     * `{:datetime, precision}` - DateTime type with millisecond/microsecond/nanosecond precision that unwraps to `Elixir.NaiveDateTime`
     * `{:duration, precision}` - Duration type with millisecond/microsecond/nanosecond precision that unwraps to `Explorer.Duration`
     * `{:f, size}` - a 64-bit or 32-bit floating point number. The atom `:float` can be used as an alias for `{:f, 64}`.
+      The atoms `:f32` and `:f64` can be used as shortcuts for `{:f, 32}` and `{:f, 64}` respectively.
     * `:integer` - 64-bit signed integer
     * `:string` - UTF-8 encoded binary
     * `:time` - Time type that unwraps to `Elixir.Time`
@@ -264,6 +265,18 @@ defmodule Explorer.Series do
         string ["1", nil]
       >
 
+      iex> Explorer.Series.from_list([1, 2], dtype: :f32)
+      #Explorer.Series<
+        Polars[2]
+        f32 [1.0, 2.0]
+      >
+
+      iex> Explorer.Series.from_list([1, nil, 2], dtype: :float)
+      #Explorer.Series<
+        Polars[3]
+        f64 [1.0, nil, 2.0]
+      >
+
   The `dtype` option is particulary important if a `:binary` series is desired, because
   by default binary series will have the dtype of `:string`:
 

lib/explorer/shared.ex

@@ -38,7 +38,8 @@ defmodule Explorer.Shared do
   end
 
   def normalise_dtype(dtype) when dtype in @non_list_types, do: dtype
-  def normalise_dtype(:float), do: {:f, 64}
+  def normalise_dtype(dtype) when dtype in [:float, :f64], do: {:f, 64}
+  def normalise_dtype(:f32), do: {:f, 32}
   def normalise_dtype(_dtype), do: nil
 
   @doc """

test/explorer/series_test.exs

@@ -148,10 +148,23 @@ defmodule Explorer.SeriesTest do
     end
 
     test "integers as {:f, 64}" do
-      s = Series.from_list([1, 2, 3, 4], dtype: :float)
-      assert s[0] == 1.0
-      assert Series.to_list(s) === [1.0, 2.0, 3.0, 4.0]
-      assert Series.dtype(s) == {:f, 64}
+      # Shortcuts and the "real" dtype
+      for dtype <- [:float, :f64, {:f, 64}] do
+        s = Series.from_list([1, 2, 3, 4], dtype: dtype)
+        assert s[0] === 1.0
+        assert Series.to_list(s) === [1.0, 2.0, 3.0, 4.0]
+        assert Series.dtype(s) === {:f, 64}
+      end
+    end
+
+    test "integers as {:f, 32}" do
+      # Shortcut and the "real" dtype
+      for dtype <- [:f32, {:f, 32}] do
+        s = Series.from_list([1, 2, 3, 4], dtype: dtype)
+        assert s[0] === 1.0
+        assert Series.to_list(s) === [1.0, 2.0, 3.0, 4.0]
+        assert Series.dtype(s) === {:f, 32}
+      end
     end
 
     test "mixing integers with an invalid atom" do