Class: RDF::Literal::Double

Inherits:
Numeric show all
Defined in:
lib/rdf/model/literal/double.rb

Overview

An floating point number literal.

Examples:

Arithmetic with floating point literals

RDF::Literal(1.0) + 0.5                 #=> RDF::Literal(1.5)
RDF::Literal(3.0) - 6                   #=> RDF::Literal(-3.0)
RDF::Literal(Math::PI) * 2              #=> RDF::Literal(Math::PI * 2)
RDF::Literal(Math::PI) / 2              #=> RDF::Literal(Math::PI / 2)

See Also:

Since:

  • 0.2.1

Constant Summary collapse

DATATYPE =

Since:

  • 0.2.1

RDF::XSD.double
GRAMMAR =

Since:

  • 0.2.1

/^(?:NaN|(?:[\+\-]?(?:INF|(?:\d+(\.\d*)?([eE][\+\-]?\d+)?))))$/.freeze

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 Numeric

#*, #+, #+@, #-, #-@, #/, #to_d, #to_f, #to_i, #to_r

Methods inherited from RDF::Literal

#compatible?, #comperable_datatype?, datatype_map, datatyped_class, #eql?, #escape, #freeze, #has_datatype?, #has_language?, #hash, #humanize, #inspect, #literal?, new, #object, #plain?, #simple?, #valid?, #validate!, #value, #value_hash

Methods included from Term

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

Methods included from Value

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

Constructor Details

#initialize(value, options = {}) ⇒ Double

Returns a new instance of Double.

Options Hash (options):

  • :lexical (String) — default: nil

Since:

  • 0.2.1



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/rdf/model/literal/double.rb', line 20

def initialize(value, options = {})
  @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
  @string   = options[:lexical] if options.has_key?(:lexical)
  @string   ||= value if value.is_a?(String)
  @object   = case
    when value.is_a?(::String) then case value
      when '+INF'  then 1/0.0
      when 'INF'  then 1/0.0
      when '-INF' then -1/0.0
      when 'NaN'  then 0/0.0
      else Float(value.sub(/\.[eE]/, '.0E')) rescue nil
    end
    when value.is_a?(::Float)     then value
    when value.respond_to?(:to_f) then value.to_f
    else Float(value.to_s) rescue nil # FIXME
  end
end

Instance Method Details

#<=>(other) ⇒ Integer

Compares this literal to ‘other` for sorting purposes.

Since:

  • 0.3.0



89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/rdf/model/literal/double.rb', line 89

def <=>(other)
  case other
    when ::Numeric
      to_f <=> other
    when RDF::Literal::Decimal
      to_f <=> other.to_d
    when RDF::Literal::Double
      to_f <=> other.to_f
    else super
  end
end

#==(other) ⇒ Boolean

Returns ‘true` if this literal is equal to `other`.

Since:

  • 0.3.0



74
75
76
77
78
79
80
81
 
# File 'lib/rdf/model/literal/double.rb', line 74

def ==(other)
  if valid? && infinite? && other.respond_to?(:infinite?) && other.infinite?
    infinite? == other.infinite?
    # JRuby INF comparisons differ from MRI
  else
    super
  end
end

#abs ⇒ RDF::Literal

Returns the absolute value of ‘self`.

Since:

  • 0.2.3



180
181
182
 
# File 'lib/rdf/model/literal/double.rb', line 180

def abs
  (f = to_f) && f > 0 ? self : self.class.new(f.abs)
end

#canonicalize! ⇒ RDF::Literal

Converts this literal into its canonical lexical representation.

See Also:

Since:

  • 0.2.1



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/rdf/model/literal/double.rb', line 43

def canonicalize!
  # Can't use simple %f transformation due to special requirements from
  # N3 tests in representation
  @string = case
    when @object.nan?      then 'NaN'
    when @object.infinite? then @object.to_s[0...-'inity'.length].upcase
    when @object.zero?     then '0.0E0'
    else
      i, f, e = ('%.15E' % @object.to_f).split(/[\.E]/)
      f.sub!(/0*$/, '')           # remove any trailing zeroes
      f = '0' if f.empty?         # ...but there must be a digit to the right of the decimal point
      e.sub!(/^(?:\+|(\-))?0+(\d+)$/, '\1\2') # remove the optional leading '+' sign and any extra leading zeroes
      "#{i}.#{f}E#{e}"
  end

  @object = case @string
  when 'NaN'  then 0/0.0
  when 'INF'  then 1/0.0
  when '-INF' then -1/0.0
  else             Float(@string)
  end

  self
end

#ceil ⇒ RDF::Literal

Returns the smallest number greater than or equal to ‘self`.

Examples:

RDF::Literal(1.2).ceil            #=> RDF::Literal(2)
RDF::Literal(-1.2).ceil           #=> RDF::Literal(-1)
RDF::Literal(2.0).ceil            #=> RDF::Literal(2)
RDF::Literal(-2.0).ceil           #=> RDF::Literal(-2)

Since:

  • 0.2.3



156
157
158
 
# File 'lib/rdf/model/literal/double.rb', line 156

def ceil
  self.class.new(to_f.ceil)
end

#finite? ⇒ Boolean

Returns ‘true` if the value is a valid IEEE floating point number (it is not infinite, and `nan?` is `false`).

Examples:

RDF::Literal(-1.0).finite?        #=> true
RDF::Literal(1.0/0.0).finite?     #=> false
RDF::Literal(0.0/0.0).finite?     #=> false

Since:

  • 0.2.3



126
127
128
 
# File 'lib/rdf/model/literal/double.rb', line 126

def finite?
  to_f.finite?
end

#floor ⇒ RDF::Literal

Returns the largest number less than or equal to ‘self`.

Examples:

RDF::Literal(1.2).floor           #=> RDF::Literal(1)
RDF::Literal(-1.2).floor          #=> RDF::Literal(-2)
RDF::Literal(2.0).floor           #=> RDF::Literal(2)
RDF::Literal(-2.0).floor          #=> RDF::Literal(-2)

Since:

  • 0.2.3



171
172
173
 
# File 'lib/rdf/model/literal/double.rb', line 171

def floor
  self.class.new(to_f.floor)
end

#infinite? ⇒ Integer

Returns ‘nil`, `-1`, or `+1` depending on whether the value is finite, `-INF`, or `+INF`.

Examples:

RDF::Literal(0.0/0.0).infinite?   #=> nil
RDF::Literal(-1.0/0.0).infinite?  #=> -1
RDF::Literal(+1.0/0.0).infinite?  #=> 1

Since:

  • 0.2.3



141
142
143
 
# File 'lib/rdf/model/literal/double.rb', line 141

def infinite?
  to_f.infinite?
end

#nan? ⇒ Boolean

Returns ‘true` if the value is an invalid IEEE floating point number.

Examples:

RDF::Literal(-1.0).nan?           #=> false
RDF::Literal(1.0/0.0).nan?        #=> false
RDF::Literal(0.0/0.0).nan?        #=> true

Since:

  • 0.2.3



111
112
113
 
# File 'lib/rdf/model/literal/double.rb', line 111

def nan?
  to_f.nan?
end

#nonzero? ⇒ Boolean

Returns ‘self` if the value is not zero, `nil` otherwise.

Since:

  • 0.2.3



206
207
208
 
# File 'lib/rdf/model/literal/double.rb', line 206

def nonzero?
  to_f.nonzero? ? self : nil
end

#round ⇒ RDF::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.

Since:

  • 0.2.1



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

def round
  self.class.new(to_f.round)
end

#to_s ⇒ String

Returns the value as a string.

Since:

  • 0.2.1



214
215
216
217
218
219
220
 
# File 'lib/rdf/model/literal/double.rb', line 214

def to_s
  @string || case
    when @object.nan?      then 'NaN'
    when @object.infinite? then @object.to_s[0...-'inity'.length].upcase
    else @object.to_s
  end
end

#zero? ⇒ Boolean

Returns ‘true` if the value is zero.

Since:

  • 0.2.3



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

def zero?
  to_f.zero?
end