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::URI("http://www.w3.org/2001/XMLSchema#double")
GRAMMAR =

Since:

  • 0.2.1

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

Approximation of the mathematical constant π

From the XQuery function math:pi.

Double.new(Math::PI)

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

#%, #*, #**, #+, #[email protected], #-, #[email protected], #/, #acos, #asin, #atan, #atan2, #cos, #exp, #exp10, #log, #log10, #sin, #sqrt, #tan, #to_d, #to_f, #to_i, #to_r

Methods inherited from RDF::Literal

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

Methods included from Term

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

Methods included from Value

#anonymous?, #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

#initialize(value, datatype: nil, lexical: nil, **options) ⇒ Double

Returns a new instance of Double.

Parameters:

  • value (String, Float, #to_f)
  • value (Object)
  • language (Symbol)

    (nil) Language is downcased to ensure proper matching

  • lexical (String) (defaults to: nil)

    (nil) Supplied lexical representation of this literal, otherwise it comes from transforming value to a string form..

  • datatype (URI) (defaults to: nil)

    (nil)

  • validate (Boolean)

    (false)

  • canonicalize (Boolean)

    (false)

Since:

  • 0.2.1


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

def initialize(value, datatype: nil, lexical: nil, **options)
  @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
  @string   = lexical || (value if value.is_a?(String))
  @object   = case
    when value.is_a?(::String) then case value.upcase
      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 0.0 # FIXME
  end
end

Dynamic Method Handling

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

Instance Method Details

#<=>(other) ⇒ Integer

Compares this literal to other for sorting purposes.

Parameters:

  • other (Object)

Returns:

Since:

  • 0.3.0


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

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.

Parameters:

  • other (Object)

Returns:

Since:

  • 0.3.0


82
83
84
85
86
87
88
89
# File 'lib/rdf/model/literal/double.rb', line 82

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

#absRDF::Literal

Returns the absolute value of self.

From the XQuery function fn:abs.


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

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.

Returns:

See Also:

Since:

  • 0.2.1


50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
# File 'lib/rdf/model/literal/double.rb', line 50

def canonicalize!
  # Can't use simple %f transformation due to special requirements from
  # N3 tests in representation
  @string = case
    when @object.nil?      then 'NaN'
    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

#ceilRDF::Literal::Integer

Returns the smallest integer greater than or equal to self.

From the XQuery function fn:ceil.

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)

Returns:

See Also:

Since:

  • 0.2.3


167
168
169
# File 'lib/rdf/model/literal/double.rb', line 167

def ceil
  RDF::Literal::Integer.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

Returns:

Since:

  • 0.2.3


134
135
136
# File 'lib/rdf/model/literal/double.rb', line 134

def finite?
  to_f.finite?
end

#floorRDF::Literal::Integer

Returns the largest integer less than or equal to self.

From the XQuery function fn:floor.

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)

Returns:

See Also:

Since:

  • 0.2.3


185
186
187
# File 'lib/rdf/model/literal/double.rb', line 185

def floor
  RDF::Literal::Integer.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

Returns:

Since:

  • 0.2.3


149
150
151
# File 'lib/rdf/model/literal/double.rb', line 149

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

Returns:

Since:

  • 0.2.3


119
120
121
# File 'lib/rdf/model/literal/double.rb', line 119

def nan?
  to_f.nan?
end

#nonzero?Boolean

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

Returns:

Since:

  • 0.2.3


226
227
228
# File 'lib/rdf/model/literal/double.rb', line 226

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

#roundRDF::Literal::Double

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.

From the XQuery function fn:round.


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

def round
  self.class.new(to_d.round(half: (to_d < 0 ? :down : :up)))
end

#to_sString

Returns the value as a string.

Returns:

Since:

  • 0.2.1


234
235
236
237
238
239
240
# File 'lib/rdf/model/literal/double.rb', line 234

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.

Returns:

Since:

  • 0.2.3


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

def zero?
  to_f.zero?
end