rdf-n3 2.2.0 → 3.1.2

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

@@ -0,0 +1,41 @@
+module RDF::N3::Algebra::Math
+  ##
+  # True iff the subject is a string representation of a number which  is less than the number of which the object is a string representation.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-less-than
+  class LessThan < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathLessThan
+    URI = RDF::N3::Math.lessThan
+
+    ##
+    # 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 less 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

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

@@ -0,0 +1,38 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject or object is calculated to be the negation of the other.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-unary-minus
+  class Negation < RDF::N3::Algebra::ResourceOperator
+    include RDF::N3::Algebra::Builtin
+
+    NAME = :mathNegation
+    URI = RDF::N3::Math.negation
+
+    ##
+    # The math:negation operator takes may have either a bound subject or object.
+    #
+    # @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
+        resource
+      when RDF::Literal
+        as_literal(-resource.as_number)
+      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/not_equal_to.rb

@@ -0,0 +1,25 @@
+module RDF::N3::Algebra::Math
+  ##
+  # True iff the subject is a string representation of a number which  is NOT EQUAL to a number of which the object is a string representation.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-equal
+  class NotEqualTo < EqualTo
+    NAME = :mathNotEqualTo
+    URI = RDF::N3::Math.notEqualTo
+
+    ##
+    # The math:notEqualTo operator takes a pair of strings or numbers and determines if they are not 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(super != RDF::Literal::TRUE)
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module RDF::N3::Algebra::Math
+  ##
+  # True iff the subject is a string representation of a number which is NOT 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 NotGreaterThan < GreaterThan
+    NAME = :mathNotGreaterThan
+    URI = RDF::N3::Math.notGreaterThan
+
+    ##
+    # Returns TRUE if `term1` is less than or equal to `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(super != RDF::Literal::TRUE)
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module RDF::N3::Algebra::Math
+  ##
+  # True iff the subject is a string representation of a number which  is NOT LESS than a number of which the object is a string representation.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-less-than
+  class NotLessThan < LessThan
+    NAME = :mathNotLessThan
+    URI = RDF::N3::Math.notLessThan
+
+    ##
+    # Returns TRUE if `term1` is greater than or equal to `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(super != RDF::Literal::TRUE)
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is a list of numbers. The object is calculated as the arithmentic product of those numbers.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-multiply
+  class Product < RDF::N3::Algebra::ListOperator
+    NAME = :mathProduct
+    URI = RDF::N3::Math.product
+
+    ##
+    # The math:product operator takes a list of strings or numbers and calculates their sum.
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      list.to_a.map(&:as_number).reduce(&:*) || RDF::Literal(1)  # Empty list product is 1
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is a pair of numbers. The object is calculated by dividing the first number of the pair by the second.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-divide
+  class Quotient < RDF::N3::Algebra::ListOperator
+    NAME = :mathQuotient
+    URI = RDF::N3::Math.quotient
+
+    ##
+    # The math:quotient operator takes a pair of strings or numbers and calculates their quotient.
+    #
+    #
+    # @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? {|le| le.is_a?(RDF::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/remainder.rb

@@ -0,0 +1,35 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is a pair of integers. The object is calculated by dividing the first number of the pair by the second and taking the remainder.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-mod
+  class Remainder < RDF::N3::Algebra::ListOperator
+    NAME = :mathRemainder
+    URI = RDF::N3::Math.remainder
+
+    ##
+    # The math:remainder operator takes a pair of strings or numbers and calculates their remainder.
+    #
+    # @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? {|li| li.is_a?(RDF::Literal) && li.as_number.is_a?(RDF::Literal::Integer)} && list.length == 2
+        true
+      else
+        log_error(NAME) {"list is not a pair of integers: #{list.to_sxp}"}
+        false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The object is calulated as the subject rounded to the nearest integer.
+  class Rounded < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathRounded
+    URI = RDF::N3::Math.rounded
+
+    ##
+    # The math:rounded operator takes string or number rounds it to the next  integer.
+    #
+    # @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.round)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is an angle expressed in radians. The object is calulated as the sine value of the subject.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-math-sin
+  class Sin < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathSin
+    URI = RDF::N3::Math.sin
+
+    ##
+    # The math:sin operator takes string or number and calculates its sine. The arc sine 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.sin(resource.as_number.object))
+        when :object
+          as_literal(Math.sinh(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/sinh.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 sine value of the subject.
+  class SinH < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathSinH
+    URI = RDF::N3::Math.sinh
+
+    ##
+    # The math:sinh operator takes string or number and calculates its hyperbolic sine. The inverse hyperbolic sine 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.sinh(resource.as_number.object))
+        when :object
+          as_literal(Math.asinh(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/sum.rb

@@ -0,0 +1,40 @@
+module RDF::N3::Algebra::Math
+  ##
+  # **schema**:
+  # `($a_1 .. $a_n) math:sum $a_s`
+  # 
+  # **summary**:
+  # performs addition of numbers
+  # 
+  # **definition**:
+  # `true` if and only if the arithmetic sum of `$a_1, .. $a_n` equals `$a_s`.
+  # Requires either:
+  # 
+  # 1. all `$a_1, .., $a_n` to be bound; or
+  # 2. all but one `$a_i` (subject list) to be bound, and `$a_s` to be bound.
+  # 
+  # **literal domains**:
+  # 
+  # * `$a_1 .. $a_n` : `xs:decimal` (or its derived types), `xs:float`, or `xs:double` (see note on type promotion, and casting from string)
+  # * `$a_s`: `xs:decimal` (or its derived types), `xs:float`, or `xs:double` (see note on type promotion, and casting from string)
+  #
+  # @example
+  #     { ("3" "5") math:sum ?x } => { ?x :valueOf "3 + 5" } .
+  #     { (3 5) math:sum ?x } => { ?x :valueOf "3 + 5 = 8" } .
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-numeric-add
+  class Sum < RDF::N3::Algebra::ListOperator
+    NAME = :mathSum
+    URI = RDF::N3::Math[:sum]
+
+    ##
+    # Evaluates to the sum of the list elements
+    #
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      list.to_a.map(&:as_number).reduce(&:+) || RDF::Literal(0)  # Empty list sums to 0
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module RDF::N3::Algebra::Math
+  ##
+  # The subject is an angle expressed in radians. The object is calulated as the tangent value of the subject.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-math-tan
+  class Tan < RDF::N3::Algebra::ResourceOperator
+    NAME = :mathTan
+    URI = RDF::N3::Math.tan
+
+    ##
+    # The math:tan operator takes string or number and calculates its tangent. The arc tangent 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.tan(resource.as_number.object))
+        when :object
+          as_literal(Math.atan(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