fixes #26

Author: zookzook

lib/bson/decimal128.ex

@@ -1,4 +1,9 @@
 defmodule BSON.Decimal128 do
+
+  @moduledoc """
+    see https://en.wikipedia.org/wiki/Decimal128_floating-point_format
+  """
+
   use Bitwise
 
   @signed_bit_mask 1 <<< 63
@@ -9,13 +14,20 @@ defmodule BSON.Decimal128 do
   @exponent_bias 6176
   @max_exponent 6111
   @min_exponent -6176
+  @s_nan_mask  0x1 <<< 57
+  @significand_mask ((0x1 <<< 49)-1)
+  @low_mask 0xffffffffffffffff
 
   def decode(<<_::little-64, high::little-64>> = bits) do
     is_negative = (high &&& @signed_bit_mask) == (@signed_bit_mask)
     combination = (high >>> 58 &&& @combination_mask)
     two_highest_bits_set = combination >>> 3 == 3
     is_infinity = two_highest_bits_set && combination == @combintation_infinity
-    is_nan = two_highest_bits_set && combination == @combintation_nan
+    is_nan = case {(two_highest_bits_set && combination) == @combintation_nan, (high &&& @s_nan_mask) == @s_nan_mask} do
+      {true, true}  -> :sNan
+      {true, false} -> :qNan
+                  _ -> false
+    end
 
     exponent = exponent(high, two_highest_bits_set)
 
@@ -29,10 +41,35 @@ defmodule BSON.Decimal128 do
     )
   end
 
+  @doc """
+  s 11110 xx...x    ±infinity
+  s 11111 0x...x    a quiet NaN
+  s 11111 1x...x    a signalling NaN
+  """
+  def encode(%Decimal{sign: -1, coef: :inf}) do
+    low = 0
+    high = 0x3e <<< 58
+    <<low::little-64, high::little-64>>
+  end
+  def encode(%Decimal{coef: :inf}) do
+    low = 0
+    high = 0x1e <<< 58
+    <<low::little-64, high::little-64>>
+  end
+  def encode(%Decimal{coef: :qNaN}) do
+    low = 0
+    high = 0x1f <<< 58
+    <<low::little-64, high::little-64>>
+  end
+  def encode(%Decimal{coef: :sNaN}) do
+    low = 0
+    high = 0x3f <<< 57
+    <<low::little-64, high::little-64>>
+  end
   def encode(%Decimal{sign: sign, coef: significand, exp: exponent}) when exponent >= @min_exponent and exponent <= @max_exponent do
     biasedExponent = exponent + @exponent_bias
-    low  = significand &&& 0xffffffff
-    high = (significand >>> 64) &&& 0xffffffff
+    low  = significand &&& @low_mask
+    high = (significand >>> 64) &&& @significand_mask ## mask max significand
     high = bor(high, biasedExponent <<< 49)
     high = case sign do
       1 -> high
@@ -41,7 +78,6 @@ defmodule BSON.Decimal128 do
 
     <<low::little-64, high::little-64>>
   end
-
   def encode(%Decimal{exp: exponent}) do
     message = "Exponent is out of range for Decimal128 encoding, #{exponent}"
     raise ArgumentError, message
@@ -51,7 +87,6 @@ defmodule BSON.Decimal128 do
     biased_exponent = (high >>> 47) &&& @exponent_mask
     biased_exponent - @exponent_bias
   end
-
   defp exponent(high, _two_highest_bits_not_set) do
     biased_exponent = (high >>> 49) &&& @exponent_mask
     biased_exponent - @exponent_bias
@@ -60,23 +95,21 @@ defmodule BSON.Decimal128 do
   defp value(%{is_negative: true, is_infinity: true}, _, _) do
     %Decimal{sign: -1, coef: :inf}
   end
-
   defp value(%{is_negative: false, is_infinity: true}, _, _) do
     %Decimal{coef: :inf}
   end
-
-  defp value(%{is_nan: true}, _, _) do
+  defp value(%{is_nan: :qNan}, _, _) do
     %Decimal{coef: :qNaN}
   end
-
+  defp value(%{is_nan: :sNan}, _, _) do
+    %Decimal{coef: :sNaN}
+  end
   defp value(%{two_highest_bits_set: true}, _, _) do
     %Decimal{sign: 0, coef: 0, exp: 0}
   end
-
   defp value(%{is_negative: true}, coef, exponent) do
     %Decimal{sign: -1, coef: coef, exp: exponent}
   end
-
   defp value(_, coef, exponent) do
     %Decimal{coef: coef, exp: exponent}
   end

test/bson/decimal128_test.exs

@@ -40,6 +40,33 @@ defmodule BSON.Decimal128Test do
     assert_decimal(@binaries_neg_tiny, %Decimal{sign: -1, coef: 1, exp: -6176})
   end
 
+  @tag :mongo_3_4
+  test "BSON.Decimal128.encode/1" do
+    assert_decimal(%Decimal{coef: :qNaN})
+    assert_decimal(%Decimal{coef: :sNaN})
+    assert_decimal(%Decimal{sign: -1, coef: :inf})
+    assert_decimal(%Decimal{coef: :inf})
+    assert_decimal(%Decimal{coef: 0, exp: -611})
+    assert_decimal(%Decimal{sign: -1, coef: 0, exp: -1})
+    assert_decimal(%Decimal{coef: 1, exp: 3})
+    assert_decimal(%Decimal{coef: 1234, exp: -6})
+    assert_decimal(%Decimal{coef: 123400000, exp: -11})
+    assert_decimal(%Decimal{coef: 1234567890123456789012345678901234, exp: -34})
+    assert_decimal(%Decimal{coef: 1234567890123456789012345678901234, exp: 0})
+    assert_decimal(%Decimal{coef: 9999999999999999999999999999999999, exp: -6176})
+    assert_decimal(%Decimal{coef: 1, exp: -6176})
+    assert_decimal(%Decimal{sign: -1, coef: 1, exp: -6176})
+  end
+
+  defp assert_decimal(expected_decimal) do
+
+    value = expected_decimal
+    |> BSON.Decimal128.encode()
+    |> BSON.Decimal128.decode()
+
+    assert value == expected_decimal
+  end
+
   defp assert_decimal(binaries, expected_decimal) do
     assert BSON.Decimal128.decode(binaries) == expected_decimal
   end

test/mongo_test.exs

@@ -556,10 +556,31 @@ defmodule Mongo.Test do
   @tag :mongo_3_4
   test "correctly query NumberDecimal", c do
     coll = "number_decimal_test"
-    Mongo.insert_one(c.pid, coll, %{number: Decimal.from_float(123.456), index: 1})
-    Mongo.insert_one(c.pid, coll, %{number: Decimal.from_float(-123.456), index: 2})
-    assert %{"number" => %Decimal{coef: 123456, exp: -3}} = Mongo.find(c.pid, coll, %{index: 1}, limit: 1) |> Enum.to_list |> List.first()
-    assert %{"number" => %Decimal{sign: -1, coef: 123456, exp: -3}} = Mongo.find(c.pid, coll, %{index: 2}, limit: 1) |> Enum.to_list |> List.first()
+
+    Mongo.delete_many(c.pid, coll, %{})
+
+    values = [
+    %Decimal{coef: :qNaN},
+    %Decimal{coef: :sNaN},
+    %Decimal{sign: -1, coef: :inf},
+    %Decimal{coef: :inf},
+    %Decimal{coef: 0, exp: -611},
+    %Decimal{sign: -1, coef: 0, exp: -1},
+    %Decimal{coef: 1, exp: 3},
+    %Decimal{coef: 1234, exp: -6},
+    %Decimal{coef: 123400000, exp: -11},
+    %Decimal{coef: 1234567890123456789012345678901234, exp: -34},
+    %Decimal{coef: 1234567890123456789012345678901234, exp: 0},
+    %Decimal{coef: 9999999999999999999999999999999999, exp: -6176},
+    %Decimal{coef: 1, exp: -6176},
+    %Decimal{sign: -1, coef: 1, exp: -6176}] |> Enum.with_index()
+
+    Enum.each(values, fn {dec, i} -> Mongo.insert_one(c.pid, coll, %{number: dec, index: i}) end)
+
+    Enum.each(values, fn {dec, i} ->
+      assert %{"number" => ^dec} = Mongo.find(c.pid, coll, %{index: i}, limit: 1) |> Enum.to_list |> List.first()
+    end)
+
   end
 
   test "access multiple databases", c do