Class: RDF::Literal::Numeric

Inherits:
RDF::Literal show all
Defined in:
lib/rdf/model/literal/numeric.rb

Overview

Shared methods and class ancestry for numeric literal classes.

Since:

  • 0.3.0

Direct Known Subclasses

Decimal, Double

Constant Summary

Constants inherited from RDF::Literal

FALSE, TRUE, ZERO

Instance Attribute Summary

Attributes inherited from RDF::Literal

#datatype, #language

Instance Method Summary collapse

Methods inherited from RDF::Literal

#canonicalize!, #compatible?, #comperable_datatype2?, #comperable_datatype?, #datatype?, #eql?, #escape, #hash, #humanize, #initialize, #inspect, #language?, #literal?, #method_missing, #object, #plain?, #respond_to_missing?, #simple?, #squish, #squish!, #to_s, #valid?, #validate!, #value, #value_hash

Methods included from Term

#compatible?, #eql?, #escape, #term?, #terms, #to_base, #to_term

Methods included from Value

#anonymous?, #canonicalize, #canonicalize!, #constant?, #graph?, #inspect, #inspect!, #invalid?, #iri?, #list?, #literal?, #node?, #resource?, #start_with?, #statement?, #term?, #to_nquads, #to_ntriples, #to_rdf, #to_term, #type_error, #uri?, #valid?, #validate!, #variable?

Constructor Details

This class inherits a constructor from RDF::Literal

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class RDF::Literal

Instance Method Details

#%(other) ⇒ RDF::Literal

Exponent − Performs remainder of self divided by other.

Parameters:

Returns:

See Also:

Since:

  • 0.2.3


150
151
152
153
154
155
156
157
158
159
160
# File 'lib/rdf/model/literal/numeric.rb', line 150

def %(other)
  if self.class == Double || [Double, ::Float].include?(other.class)
    self.class.new(to_f % other.to_f)
  elsif ((self.class == RDF::Literal::Float || other.class == RDF::Literal::Float) rescue false)
    self.class.new(to_f % other.to_f)
  elsif self.class == Decimal || other.class == Decimal
    self.class.new(to_d % (other.respond_to?(:to_d) ? other.to_d : BigDecimal(other.to_s)))
  else
    self.class.new(to_i % other.to_i)
  end
end

#*(other) ⇒ RDF::Literal::Numeric

Returns the product of self times other.


116
117
118
119
120
121
122
123
124
125
126
# File 'lib/rdf/model/literal/numeric.rb', line 116

def *(other)
  if self.class == Double || [Double, ::Float].include?(other.class)
    RDF::Literal::Double.new(to_f * other.to_f)
  elsif ((self.class == RDF::Literal::Float || other.class == RDF::Literal::Float) rescue false)
    RDF::Literal::Float.new(to_f * other.to_f)
  elsif self.class == Decimal || other.class == Decimal
    RDF::Literal::Decimal.new(to_d * (other.respond_to?(:to_d) ? other.to_d : BigDecimal(other.to_s)))
  else
    RDF::Literal::Integer.new(to_i * other.to_i)
  end
end

#**(other) ⇒ RDF::Literal::Numeric

Exponent − Performs exponential (power) calculation on operators.

Promotes values, as necessary, with the result type depending on the input values.


137
138
139
140
141
# File 'lib/rdf/model/literal/numeric.rb', line 137

def **(other)
  RDF::Literal(object ** (other.is_a?(RDF::Literal::Numeric) ? other.object : other))
rescue ZeroDivisionError
  RDF::Literal::Double.new('INF')
end

#+(other) ⇒ RDF::Literal::Numeric

Returns the sum of self plus other.

For xs:float or xs:double values, if one of the operands is a zero or a finite number and the other is INF or -INF, INF or -INF is returned. If both operands are INF, INF is returned. If both operands are -INF, -INF is returned. If one of the operands is INF and the other is -INF, NaN is returned.


78
79
80
81
82
83
84
85
86
87
88
# File 'lib/rdf/model/literal/numeric.rb', line 78

def +(other)
  if self.class == Double || [Double, ::Float].include?(other.class)
    RDF::Literal::Double.new(to_f + other.to_f)
  elsif ((self.class == RDF::Literal::Float || other.class == RDF::Literal::Float) rescue false)
    RDF::Literal::Float.new(to_f + other.to_f)
  elsif self.class == Decimal || other.class == Decimal
    RDF::Literal::Decimal.new(to_d + (other.respond_to?(:to_d) ? other.to_d : BigDecimal(other.to_s)))
  else
    RDF::Literal::Integer.new(to_i + other.to_i)
  end
end

#[email protected]RDF::Literal::Numeric

Returns self.

Returns:

Since:

  • 0.2.3


54
55
56
# File 'lib/rdf/model/literal/numeric.rb', line 54

def [email protected]
  self # unary plus
end

#-(other) ⇒ RDF::Literal::Numeric

Returns the difference of self minus other.


97
98
99
100
101
102
103
104
105
106
107
# File 'lib/rdf/model/literal/numeric.rb', line 97

def -(other)
  if self.class == Double || [Double, ::Float].include?(other.class)
    RDF::Literal::Double.new(to_f - other.to_f)
  elsif ((self.class == RDF::Literal::Float || other.class == RDF::Literal::Float) rescue false)
    RDF::Literal::Float.new(to_f - other.to_f)
  elsif self.class == Decimal || other.class == Decimal
    RDF::Literal::Decimal.new(to_d - (other.respond_to?(:to_d) ? other.to_d : BigDecimal(other.to_s)))
  else
    RDF::Literal::Integer.new(to_i - other.to_i)
  end
end

#[email protected]RDF::Literal::Numeric

Returns self negated.

Returns:

Since:

  • 0.2.3


63
64
65
# File 'lib/rdf/model/literal/numeric.rb', line 63

def [email protected]
  self.class.new(-self.object)
end

#/(other) ⇒ RDF::Literal::Numeric

Returns the quotient of self divided by other.

As a special case, if the types of both $arg1 and $arg2 are xsd:integer, then the return type is xsd:decimal.

Parameters:

Returns:

Raises:

  • (ZeroDivisionError)

    if divided by zero

See Also:

Since:

  • 0.2.3


173
174
175
176
177
178
179
180
181
# File 'lib/rdf/model/literal/numeric.rb', line 173

def /(other)
  if self.class == Double || [Double, ::Float].include?(other.class)
    RDF::Literal::Double.new(to_f / other.to_f)
  elsif ((self.class == RDF::Literal::Float || other.class == RDF::Literal::Float) rescue false)
    RDF::Literal::Float.new(to_f / other.to_f)
  else
    RDF::Literal::Decimal.new(to_d / (other.respond_to?(:to_d) ? other.to_d : BigDecimal(other.to_s)))
  end
end

#<=>(other) ⇒ Integer

Compares this literal to other for sorting purposes.

Parameters:

  • other (Object)

Returns:

Since:

  • 0.3.0


13
14
15
16
17
18
19
20
21
22
23
24
25
26
# File 'lib/rdf/model/literal/numeric.rb', line 13

def <=>(other)
  # If lexically invalid, use regular literal testing
  return super unless self.valid? && (!other.respond_to?(:valid?) || other.valid?)

  case other
    when ::Numeric
      to_d <=> other
    when Double
      to_f <=> other.to_f
    when Numeric
      to_d <=> other.to_d
    else super
  end
end

#==(other) ⇒ Boolean

Returns true if this literal is equal to other.

Parameters:

  • other (Object)

Returns:

Since:

  • 0.3.0


34
35
36
37
38
39
40
41
42
43
44
45
46
47
# File 'lib/rdf/model/literal/numeric.rb', line 34

def ==(other)
  # If lexically invalid, use regular literal testing
  return super unless self.valid? && (!other.respond_to?(:valid?) || other.valid?)

  case other
  when Literal::Numeric
    (cmp = (self <=> other)) ? cmp.zero? : false
  when RDF::URI, RDF::Node
    # Interpreting SPARQL data-r2/expr-equal/eq-2-2, numeric can't be compared with other types
    type_error("unable to determine whether #{self.inspect} and #{other.inspect} are equivalent")
  else
    super
  end
end

#absRDF::Literal

Returns the absolute value of self.

Returns:

Raises:

  • (NotImplementedError)

    unless implemented in subclass

Since:

  • 0.3.0


188
189
190
# File 'lib/rdf/model/literal/numeric.rb', line 188

def abs
  raise NotImplementedError
end

#ceilRDF::Literal

Returns the smallest integer greater than or equal to self.

Examples:

RDF::Literal(1).ceil            #=> RDF::Literal(1)

Returns:

Since:

  • 0.3.0


208
209
210
# File 'lib/rdf/model/literal/numeric.rb', line 208

def ceil
  self
end

#floorRDF::Literal

Returns the largest integer less than or equal to self.

Examples:

RDF::Literal(1).floor            #=> RDF::Literal(1)

Returns:

Since:

  • 0.3.0


219
220
221
# File 'lib/rdf/model/literal/numeric.rb', line 219

def floor
  self
end

#roundRDF::Literal

Returns the number with no fractional part that is closest to the argument. If there are two such numbers, then the one that is closest to positive infinity is returned. An error is raised if arg is not a numeric value.

Returns:

Raises:

  • (NotImplementedError)

    unless implemented in subclass

Since:

  • 0.3.0


197
198
199
# File 'lib/rdf/model/literal/numeric.rb', line 197

def round
  raise NotImplementedError
end

#to_dBigDecimal

Returns the value as a decimal number.

Returns:

  • (BigDecimal)

Since:

  • 0.3.0


248
249
250
251
252
# File 'lib/rdf/model/literal/numeric.rb', line 248

def to_d
  @object.respond_to?(:to_d) ? @object.to_d : BigDecimal(@object.to_s)
rescue FloatDomainError
  ::Float::NAN
end

#to_fFloat

Returns the value as a floating point number.

The usual accuracy limits and errors of binary float arithmetic apply.

Returns:

  • (Float)

See Also:

  • BigDecimal#to_f

Since:

  • 0.3.0


240
241
242
# File 'lib/rdf/model/literal/numeric.rb', line 240

def to_f
  @object.to_f
end

#to_iInteger Also known as: to_int, ord

Returns the value as an integer.

Returns:

Since:

  • 0.3.0


227
228
229
# File 'lib/rdf/model/literal/numeric.rb', line 227

def to_i
  @object.to_i
end

#to_rRational

Returns the value as a rational number.

Returns:

  • (Rational)

Since:

  • 0.3.0


258
259
260
# File 'lib/rdf/model/literal/numeric.rb', line 258

def to_r
  @object.to_r
end