Add native support for Rational to xsd:double. Update Literal::Numeric#** to use the type of the native result, rather than always double.

Author: gkellogg

lib/rdf/model/literal.rb

@@ -118,6 +118,7 @@ def self.new(value, language: nil, datatype: nil, lexical: nil, validate: false,
           when ::Integer    then RDF::Literal::Integer
           when ::Float      then RDF::Literal::Double
           when ::BigDecimal then RDF::Literal::Decimal
+          when ::Rational   then RDF::Literal::Double
           when ::DateTime   then RDF::Literal::DateTime
           when ::Time       then RDF::Literal::DateTime
           when ::Date       then RDF::Literal::Date

lib/rdf/model/literal/numeric.rb

@@ -126,16 +126,16 @@ def *(other)
     ##
     # Exponent − Performs exponential (power) calculation on operators.
     #
-    # If other is an instance of xs:integer, the result is self raised to the power of other as defined in the [IEEE 754-2008] specification of the pown function applied to a 64-bit binary floating point value and an integer.
-    #
-    # Otherwise $y is converted to an xs:double by numeric promotion, and the result is the value of $x raised to the power of $y as defined in the [IEEE 754-2008] specification of the pow function applied to two 64-bit binary floating point values.
+    # Promotes values, as necessary, with the result type depending on the input values.
     #
     # @param  [Literal::Numeric, #to_i, #to_f, #to_d] other
-    # @return [RDF::Literal::Double]
+    # @return [RDF::Literal::Numeric]
     # @since  0.2.3
     # @see https://www.w3.org/TR/xpath-functions/#func-math-pow
     def **(other)
-      RDF::Literal::Double.new(to_f ** other.to_f)
+      RDF::Literal(object ** (other.is_a?(RDF::Literal::Numeric) ? other.object : other))
+    rescue ZeroDivisionError
+      RDF::Literal::Double.new('INF')
     end
 
     ##

spec/model_literal_spec.rb

@@ -22,6 +22,7 @@ def self.literal(selector)
     when :int         then [123]
     when :long        then [9223372036854775807]
     when :double      then [3.1415]
+    when :decimal     then [BigDecimal("1.2")]
     when :date        then [Date.new(2010)]
     when :datetime    then [DateTime.new(2011)]
     when :time        then ['01:02:03Z', {datatype: RDF::XSD.time}]
@@ -35,7 +36,7 @@ def self.literals(*selector)
       ary += case sel
       when :all_simple        then [:empty, :plain, :string].map {|s| literal(s)}
       when :all_plain_lang    then [:empty_lang, :plain_lang].map {|s| literal(s)}
-      when :all_native        then [:false, :true, :int, :long, :double, :time, :date, :datetime].map {|s| literal(s)}
+      when :all_native        then [:false, :true, :int, :long, :decimal, :double, :time, :date, :datetime].map {|s| literal(s)}
       when :all_invalid_lang  then [:wrong_lang, :unset_lang].map {|s| literal(s)}
       when :all_plain         then literals(:all_simple, :all_plain_lang)
       else                         literals(:all_plain, :all_native)
@@ -142,8 +143,10 @@ def self.literals(*selector)
       false => "boolean",
       9223372036854775807 => "integer",
       3.1415 => "double",
+      BigDecimal("1.2") => "decimal",
       Date.new(2010) => "date",
       DateTime.new(2011) => "dateTime",
+      Rational("1/3") => "double",
       Time.parse("01:02:03Z") => "dateTime"
     }.each_pair do |value, type|
       it "returns xsd.#{type} for #{value.inspect} #{value.class}" do
@@ -470,13 +473,13 @@ def self.literals(*selector)
 
     describe "#**" do
       {
-        "2^3": [2, 3, 8.0e0],
-        "-2^3": [-2, 3, -8.0e0],
+        "2^3": [2, 3, 8],
+        "-2^3": [-2, 3, -8],
         "2^-3": [2, -3, 0.125e0],
         "-2^-3": [-2, -3, -0.125e0],
-        "2^0": [2, 0, 1.0e0],
-        "0^0": [0, 0, 1.0e0],
-        "0^4": [0, 4, 0.0e0],
+        "2^0": [2, 0, 1],
+        "0^0": [0, 0, 1],
+        "0^4": [0, 4, 0],
         "0^-4": [0, -4, RDF::Literal::Double.new('INF')],
         "16^0.5e0": [16, 0.5e0, 4.0e0],
         "16^0.25e0": [16, 0.25e0, 2.0e0],
@@ -488,6 +491,7 @@ def self.literals(*selector)
       }.each do |name, (n, e, result)|
         it name do
           expect(RDF::Literal(n) ** RDF::Literal(e)).to eq RDF::Literal(result)
+          expect((RDF::Literal(n) ** RDF::Literal(e)).datatype).to eq RDF::Literal(result).datatype
         end
       end
     end
@@ -567,13 +571,25 @@ def self.literals(*selector)
 
     describe "#%" do
       {
-        "4.5 % 1.2": [RDF::Literal::Decimal.new("4.5"), RDF::Literal::Decimal.new("1.2"), RDF::Literal::Decimal.new("0.9")],
+        "4.5 % 1.2": [BigDecimal("4.5"), BigDecimal("1.2"), BigDecimal("0.9")],
       }.each do |name, (n, e, result)|
         it name do
           expect(RDF::Literal(n) % RDF::Literal(e)).to eq RDF::Literal(result)
         end
       end
     end
+
+    describe "#**" do
+      {
+        "2.7^10": [BigDecimal("2.7"), 10, BigDecimal("20589.1132094649")],
+        "2.7^10.3": [BigDecimal("2.7"), BigDecimal("10.3"), BigDecimal("27736.1879020809118")],
+      }.each do |name, (n, e, result)|
+        it name do
+          expect(RDF::Literal(n) ** RDF::Literal(e)).to eq RDF::Literal(result)
+          expect((RDF::Literal(n) ** RDF::Literal(e)).datatype).to eq RDF::Literal(result).datatype
+        end
+      end
+    end
   end
 
   describe RDF::Literal::Double do
@@ -751,6 +767,7 @@ def self.literals(*selector)
       }.each do |name, (n, e, result)|
         it name do
           expect(RDF::Literal(n) ** RDF::Literal(e)).to eq RDF::Literal(result)
+          expect((RDF::Literal(n) ** RDF::Literal(e)).datatype).to eq RDF::Literal(result).datatype
         end
       end
     end