rdf-n3 2.2.0 → 3.1.2

data/lib/rdf/n3/algebra/math/acosh.rb

@@ -0,0 +1,26 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calulated as the inverse hyperbolic cosine value of the subject.
+  class ACosH < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathACosH
+    URI = RDF::N3::Math.acosh
+
+    ##
+    # The math:acosh operator takes string or number and calculates its inverse hyperbolic cosine.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case position
+      when :subject
+        return nil unless resource.literal?
+        as_literal(Math.acosh(resource.as_number.object))
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/asin.rb

@@ -0,0 +1,26 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calulated as the arc sine value of the subject.
+  class ASin < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathASin
+    URI = RDF::N3::Math.asin
+
+    ##
+    # The math:asin operator takes string or number and calculates its arc sine.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case position
+      when :subject
+        return nil unless resource.literal?
+        as_literal(Math.asin(resource.as_number.object))
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/asinh.rb

@@ -0,0 +1,26 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calulated as the inverse hyperbolic sine value of the subject.
+  class ASinH < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathASinH
+    URI = RDF::N3::Math.asinh
+
+    ##
+    # The math:asinh operator takes string or number and calculates its inverse hyperbolic sine.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case position
+      when :subject
+        return nil unless resource.literal?
+        as_literal(Math.asinh(resource.as_number.object))
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/atan.rb

@@ -0,0 +1,26 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calulated as the arc tangent value of the subject.
+  class ATan < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathATan
+    URI = RDF::N3::Math.atan
+
+    ##
+    # The math:atan operator takes string or number and calculates its arc tangent.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case position
+      when :subject
+        return nil unless resource.literal?
+        as_literal(Math.atan(resource.as_number.object))
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/atanh.rb

@@ -0,0 +1,26 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calulated as the inverse hyperbolic tangent value of the subject.
+  class ATanH < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathATanH
+    URI = RDF::N3::Math.atanh
+
+    ##
+    # The math:atanh operator takes string or number and calculates its inverse hyperbolic tangent.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case position
+      when :subject
+        return nil unless resource.literal?
+        as_literal(Math.atanh(resource.as_number.object))
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/ceiling.rb

@@ -0,0 +1,28 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calculated as the subject upwards to a whole number.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-ceiling
+  class Ceiling < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathCeiling
+    URI = RDF::N3::Math.ceiling
+
+    ##
+    # The math:ceiling operator takes string or number and calculates its ceiling.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case position
+      when :subject
+        return nil unless resource.literal?
+        as_literal(resource.as_number.ceil)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/cos.rb

@@ -0,0 +1,40 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is an angle expressed in radians. The object is calulated as the cosine value of the subject.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-math-cos
+  class Cos < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathCos
+    URI = RDF::N3::Math.cos
+
+    ##
+    # The math:cos operator takes string or number and calculates its cosine. The arc cosine of a concrete object can also calculate a variable subject.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case resource
+      when RDF::Query::Variable then resource
+      when RDF::Literal
+        case position
+        when :subject
+          as_literal(Math.cos(resource.as_number.object))
+        when :object
+          as_literal(Math.acos(resource.as_number.object))
+        end
+      else
+        nil
+      end
+    end
+
+    ##
+    # Input is either the subject or object
+    #
+    # @return [RDF::Term]
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/cosh.rb

@@ -0,0 +1,38 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is an angle expressed in radians. The object is calulated as the hyperbolic cosine value of the subject.
+  class CosH < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathCosH
+    URI = RDF::N3::Math.cosh
+
+    ##
+    # The math:cosh operator takes string or number and calculates its hyperbolic cosine.  The inverse hyperbolic cosine of a concrete object can also calculate a variable subject.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case resource
+      when RDF::Query::Variable then resource
+      when RDF::Literal
+        case position
+        when :subject
+          as_literal(Math.cosh(resource.as_number.object))
+        when :object
+          as_literal(Math.acosh(resource.as_number.object))
+        end
+      else
+        nil
+      end
+    end
+
+    ##
+    # Input is either the subject or object
+    #
+    # @return [RDF::Term]
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/difference.rb

@@ -0,0 +1,40 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is a pair of numbers. The object is calculated by subtracting the second number of the pair from the first.
+  #
+  # @example
+  #     { ("8" "3") math:difference ?x} => { ?x :valueOf "8 - 3" } .
+  #     { ("8") math:difference ?x } => { ?x :valueOf "8 - (error?)" } .
+  #     { (8 3) math:difference ?x} => { ?x :valueOf "8 - 3" } .
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-subtract
+  class Difference < RDF::N3::Algebra::ListOperator
+    NAME = :mathDifference
+    URI = RDF::N3::Math.difference
+
+    ##
+    # The math:difference operator takes a pair of strings or numbers and calculates their difference.
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      list.to_a.map(&:as_number).reduce(&:-)
+    end
+
+    ##
+    # The list argument must be a pair of literals.
+    #
+    # @param [RDF::N3::List] list
+    # @return [Boolean]
+    # @see RDF::N3::ListOperator#validate
+    def validate(list)
+      if super && list.all?(&:literal?) && list.length == 2
+        true
+      else
+        log_error(NAME) {"list is not a pair of literals: #{list.to_sxp}"}
+        false
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/equal_to.rb

@@ -0,0 +1,54 @@
+module RDF::N3::Algebra::Math
+  ##
+  # **schema**:
+  # `$a1 math:equalTo $a2`
+  # 
+  # **summary**:
+  # checks equality of numbers
+  # 
+  # **definition**:
+  # `true` if and only if `$a1` is equal to `$a2`. 
+  # Requires both arguments to be either concrete numerals, or variables bound to a numeral.
+  # 
+  # **literal domains**:
+  # 
+  # * `$a1`: `xs:decimal` (or its derived types), `xs:float`, or `xs:double`  (see note on type promotion, and casting from string)
+  # * `$a2`: `xs:decimal` (or its derived types), `xs:float`, or `xs:double`  (see note on type promotion, and casting from string)
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-equal
+  class EqualTo < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathEqualTo
+    URI = RDF::N3::Math.equalTo
+
+    ##
+    # Resolves inputs as numbers.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      resource.as_number if resource.term?
+    end
+
+    # Both subject and object are inputs.
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+
+    ##
+    # Returns TRUE if `term1` and `term2` are the same numeric value.
+    #
+    # @param  [RDF::Term] term1
+    #   an RDF term
+    # @param  [RDF::Term] term2
+    #   an RDF term
+    # @return [RDF::Literal::Boolean] `true` or `false`
+    # @raise  [TypeError] if either operand is not an RDF term or operands are not comperable
+    #
+    # @see RDF::Term#==
+    def apply(term1, term2)
+      RDF::Literal(term1 == term2)
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/exponentiation.rb

@@ -0,0 +1,35 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is a pair of numbers. The object is calculated by raising the first number of the power of the second.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-math-exp
+  class Exponentiation < RDF::N3::Algebra::ListOperator
+    NAME = :mathExponentiation
+    URI = RDF::N3::Math.exponentiation
+
+    ##
+    # The math:difference operator takes a pair of strings or numbers and calculates the exponent.
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      list.to_a.map(&:as_number).reduce(&:**)
+    end
+
+    ##
+    # The list argument must be a pair of literals.
+    #
+    # @param [RDF::N3::List] list
+    # @return [Boolean]
+    # @see RDF::N3::ListOperator#validate
+    def validate(list)
+      if super && list.all?(&:literal?) && list.length == 2
+        true
+      else
+        log_error(NAME) {"list is not a pair of literals: #{list.to_sxp}"}
+        false
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/floor.rb

@@ -0,0 +1,28 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calculated as the subject downwards to a whole number.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-floor
+  class Floor < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathFloor
+    URI = RDF::N3::Math.floor
+
+    ##
+    # The math:floor operator takes string or number and calculates its floor.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case position
+      when :subject
+        return nil unless resource.literal?
+        RDF::Literal(resource.as_number.floor)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/math/greater_than.rb

@@ -0,0 +1,41 @@
+module RDF::N3::Algebra::Math
+  ##
+  # True iff the subject is a string representation of a number which  is greater than the number of which the object is a string representation.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-greater-than
+  class GreaterThan < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathGreaterThan
+    URI = RDF::N3::Math.greaterThan
+
+    ##
+    # Resolves inputs as numbers.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      resource.as_number if resource.term?
+    end
+
+    # Both subject and object are inputs.
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+
+    ##
+    # Returns TRUE if `term1` is greater than `term2`.
+    #
+    # @param  [RDF::Term] term1
+    #   an RDF term
+    # @param  [RDF::Term] term2
+    #   an RDF term
+    # @return [RDF::Literal::Boolean] `true` or `false`
+    # @raise  [TypeError] if either operand is not an RDF term or operands are not comperable
+    #
+    # @see RDF::Term#==
+    def apply(term1, term2)
+      RDF::Literal(term1 > term2)
+    end
+  end
+end