class RDF::Literal::Double

An floating point number literal.

@example 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 www.w3.org/TR/xmlschema11-2/#double @since 0.2.1

Constants

DATATYPE
GRAMMAR

Public Class Methods

new(value, options = {}) click to toggle source

@param [Float, to_f] value @option options [String] :lexical (nil)

# 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

Public Instance Methods

<=>(other) click to toggle source

Compares this literal to `other` for sorting purposes.

@param [Object] other @return [Integer] `-1`, `0`, or `1` @since 0.3.0

Calls superclass method
# 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) click to toggle source

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

@param [Object] other @return [Boolean] `true` or `false` @since 0.3.0

Calls superclass method
# 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() click to toggle source

Returns the absolute value of `self`.

@return [RDF::Literal] @since 0.2.3

# File lib/rdf/model/literal/double.rb, line 180
def abs
  (f = to_f) && f > 0 ? self : self.class.new(f.abs)
end
canonicalize!() click to toggle source

Converts this literal into its canonical lexical representation.

@return [RDF::Literal] `self` @see www.w3.org/TR/xmlschema11-2/#double

# 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() click to toggle source

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

@example

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)

@return [RDF::Literal] @since 0.2.3

# File lib/rdf/model/literal/double.rb, line 156
def ceil
  self.class.new(to_f.ceil)
end
finite?() click to toggle source

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

@example

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

@return [Boolean] @since 0.2.3

# File lib/rdf/model/literal/double.rb, line 126
def finite?
  to_f.finite?
end
floor() click to toggle source

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

@example

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)

@return [RDF::Literal] @since 0.2.3

# File lib/rdf/model/literal/double.rb, line 171
def floor
  self.class.new(to_f.floor)
end
infinite?() click to toggle source

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

@example

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

@return [Integer] @since 0.2.3

# File lib/rdf/model/literal/double.rb, line 141
def infinite?
  to_f.infinite?
end
nan?() click to toggle source

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

@example

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

@return [Boolean] @since 0.2.3

# File lib/rdf/model/literal/double.rb, line 111
def nan?
  to_f.nan?
end
nonzero?() click to toggle source

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

@return [Boolean] @since 0.2.3

# File lib/rdf/model/literal/double.rb, line 206
def nonzero?
  to_f.nonzero? ? self : nil
end
round() click to toggle source

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.

@return [RDF::Literal]

# File lib/rdf/model/literal/double.rb, line 188
def round
  self.class.new(to_f.round)
end
to_s() click to toggle source

Returns the value as a string.

@return [String]

# 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?() click to toggle source

Returns `true` if the value is zero.

@return [Boolean] @since 0.2.3

# File lib/rdf/model/literal/double.rb, line 197
def zero?
  to_f.zero?
end