hex_values 0.0.3 → 0.1

data/README.md

@@ -42,6 +42,34 @@ Or transform any hexadecimal to the corresponding float:
 # => 234.25
 ```
 
+## Hexadecimal
+
+To be more precise, when you transoform a Float (or a Fixnum) to an hexadecimal, you get a Hexadecimal object. This object is a representation of the Hexadecimal value, and you can operate on this object:
+
+```ruby
+hexa = 234.25.to_hex
+result = hexa + 234.25
+result.to_s
+# => "1D4.8"
+```
+
+also you can operate over a Float (or a Fixnum) using an Hexadecimal value.
+
+```ruby
+hexa = 234.25.to_hex
+result = 234.25 + hexa # I know, this is obvious...but is better to explain that works.
+result.to_s
+# => "1D4.8"
+```
+
+So far, the operations availables are:
+
+* plus (+)
+* minus (-)
+* multiply (*)
+* division (/)
+* Power (**)
+
 ### From float to Hex
 
 The "to_hex" method allows a precision parameter to set the maximum number of decimals to calculate (default 14).

data/lib/hex_values.rb

@@ -1,44 +1,30 @@
 require "hex_values/version"
+require "hex_values/hexadecimal"
 
 module HexValuesFromFloat
-  MAX_DECIMALS = 14
-
-  def to_hex(precision = MAX_DECIMALS)
-    precision = MAX_DECIMALS if precision < 0
-
-    num,dec = get_hex_value(self)
-    first = num
-    second = ""
-    iterations = 0
-    while dec > 0 && iterations < precision
-      num, dec = get_hex_value(dec*16)
-      second << num
-      iterations += 1
-    end
-
-    if "".eql? second
-      first
-    else
-      "#{first}.#{second}"
-    end
-  end
-
-  private
-
-  def get_hex_value(float_num)
-    base, remainder = float_num.to_s.split('.')
-    [base.to_i.to_s(16).upcase, "0.#{remainder}".to_f]
+  def to_hex(precision=nil)
+    Hexadecimal.new(self, precision)
   end
 end
 
 module FloatValuesFromString
   def to_float
+    negative = false
+    str = self
+
+    if self[0].eql? "-"
+      negative = true
+      str = self[1..self.length]
+    end
+
     number = 0
     base, remainder = self.split('.')
 
     get_sum(base.split(//).reverse!) { |element, index| number += element.to_i(16) * (16 ** index) } if base
     get_sum(remainder.split(//)) { |element, index| number += element.to_i(16).to_f / (16 ** (index + 1)) } if remainder
 
+    number = number * -1 if negative
+
     number
   end
 
@@ -53,6 +39,37 @@ end
 
 class Float
   include HexValuesFromFloat
+
+  alias :old_sum :+
+  alias :old_min :-
+  alias :old_multiply :*
+  alias :old_divide :/
+  alias :old_pow :**
+
+  def +(other_obj)
+    return other_obj + self if other_obj.instance_of? Hexadecimal
+    return old_sum(other_obj)
+  end
+
+  def -(other_obj)
+    return self.to_hex - other_obj if other_obj.instance_of? Hexadecimal
+    return old_min(other_obj)
+  end
+
+  def *(other_obj)
+    return other_obj * self if other_obj.instance_of? Hexadecimal
+    return old_multiply(other_obj)
+  end
+
+  def /(other_obj)
+    return self.to_hex / other_obj if other_obj.instance_of? Hexadecimal
+    return old_divide(other_obj)
+  end
+
+  def **(other_obj)
+    return self ** other_obj.to_float if other_obj.instance_of? Hexadecimal
+    return old_pow(other_obj)
+  end
 end
 
 class String
@@ -60,7 +77,44 @@ class String
 end
 
 class Fixnum
-  def to_hex(precision=HexValuesFromFloat::MAX_DECIMALS)
+  alias :old_sum :+
+  alias :old_min :-
+  alias :old_multiply :*
+  alias :old_divide :/
+  alias :old_pow :**
+
+  def to_hex(precision=Hexadecimal::MAX_DECIMALS)
     self.to_f.to_hex(precision)
   end
+
+  def +(other_obj)
+    return other_obj + self if other_obj.instance_of? Hexadecimal
+    return old_sum(other_obj)
+  end
+
+  def -(other_obj)
+    return self.to_hex - other_obj if other_obj.instance_of? Hexadecimal
+    return old_min(other_obj)
+  end
+
+  def *(other_obj)
+    return other_obj * self if other_obj.instance_of? Hexadecimal
+    return old_multiply(other_obj)
+  end
+
+  def /(other_obj)
+    return self.to_hex / other_obj if other_obj.instance_of? Hexadecimal
+    return old_divide(other_obj)
+  end
+
+  def **(other_obj)
+    return self ** other_obj.to_float if other_obj.instance_of? Hexadecimal
+    return old_pow(other_obj)
+  end
+end
+
+class NilClass
+  def to_hex(precision=Hexadecimal::MAX_DECIMALS)
+    Hexadecimal.new(0, precision)
+  end
 end

data/lib/hex_values/hexadecimal.rb

@@ -0,0 +1,130 @@
+class Hexadecimal
+  MAX_DECIMALS = 14
+
+  def initialize(float_representation=0.0, precision=MAX_DECIMALS)
+    precision = MAX_DECIMALS if precision.nil? || precision < 0
+    @max_decimals=precision
+    @float_representation=float_representation
+  end
+
+  # Public: return the float value of the Hexadecimal.
+  #
+  # Returns the Float value of the Hexadecimal.
+  def to_float
+    @float_representation
+  end
+
+  # Public: return a String representation.
+  #
+  # Returns a String representation of the Hexadecimal object.
+  def to_s
+    return "Infinity" unless @float_representation.to_f.infinite?.nil?
+    num,dec = get_hex_value(@float_representation)
+    first = num
+    second = ""
+    iterations = 0
+    while dec > 0 && iterations < @max_decimals
+      num, dec = get_hex_value(dec*16)
+      second << num
+      iterations += 1
+    end
+
+    if "".eql? second
+      first
+    else
+      normalize_negativity "#{first}.#{second}", @float_representation
+    end
+  end
+
+  # Public: Sum two values.
+  #
+  # other_obj - An Hexadecimal object, a Fixnum or a Float
+  #
+  # Returns an Hexadecimal object, sum of the two objects.
+  def +(other_obj)
+    return operation(self, other_obj, "+".to_sym)
+  end
+
+  # Public: Substracts two values.
+  #
+  # other_obj - An Hexadecimal object, a Fixnum or a Float
+  #
+  # Returns an Hexadecimal object, the substaction of the second object over the first.
+  def -(other_obj)
+    self + (other_obj * -1)
+  end
+
+
+  # Public: Multiply two values.
+  #
+  # other_obj - An Hexadecimal object, a Fixnum or a Float
+  #
+  # Returns an Hexadecimal object, the multiplication of the operands.
+  def *(other_obj)
+    return operation(self, other_obj, "*".to_sym)
+  end
+
+  # Public: Divide two values.
+  #
+  # other_obj - An Hexadecimal object, a Fixnum or a Float
+  #
+  # Returns an Hexadecimal object, the division of the operands.
+  def /(other_obj)
+    return operation(self, other_obj, "/".to_sym)
+  end
+
+  # Public: Pow two values.
+  #
+  # other_obj - An Hexadecimal object, a Fixnum or a Float
+  #
+  # Returns an Hexadecimal object, the power of the operands.
+  def **(other_obj)
+    return operation(self, other_obj, "**".to_sym)
+  end
+
+  # Public: Transform a given string into a Hexadecimal object.
+  #
+  # hex_representation - A String representing a Hexadecimal value
+  #
+  # Examples:
+  #   Hexadecimal.from_string("EA.4")
+  #
+  # Returns an Hexadecimal object. Or throws an exception if the string can't be parsed.
+  def self.from_string(hex_representation)
+    return Hexadecimal.new if hex_representation.nil?
+    Hexadecimal.new(hex_representation.to_float)
+  end
+
+  protected
+
+  def max_decimals
+    @max_decimals
+  end
+
+  private
+
+  def get_hex_value(float_num)
+    base, remainder = float_num.to_s.split('.')
+    [base.to_i.to_s(16).upcase, "0.#{remainder}".to_f]
+  end
+
+  def normalize_negativity(string, float_num)
+    if string[0] != "-" && float_num < 0
+      "-#{string}"
+    else
+      string
+    end
+  end
+
+  def operation(hex1, hex2, operation)
+    if hex2.instance_of? Hexadecimal
+      float_result = hex1.to_float.send(operation, hex2.to_float)
+      max_precision = (hex1.max_decimals > hex2.max_decimals) ? hex1.max_decimals : hex2.max_decimals
+    else
+      float_result = hex1.to_float.send(operation, hex2)
+      max_precision = hex1.max_decimals
+    end
+
+    Hexadecimal.new(float_result, max_precision)
+  end
+end

data/lib/hex_values/version.rb

@@ -1,3 +1,3 @@
 module HexValues
-  VERSION = "0.0.3"
+  VERSION = "0.1"
 end

data/spec/hex_values/hexadecimal_spec.rb

@@ -0,0 +1,462 @@
+require 'spec_helper'
+
+describe Hexadecimal do
+  describe "from_string" do
+    it "transform a string into an Hexadecimal object" do
+      hex = Hexadecimal.from_string("EA.4")
+      hex.to_s.must_equal "EA.4"
+      hex.to_float.must_equal 234.25
+    end
+
+    it "transform an empty string into an Hexadecimal object with value 0" do
+      hex = Hexadecimal.from_string("")
+      hex.to_s.must_equal "0"
+      hex.to_float.must_equal 0.0
+    end
+
+    it "transform a negative hex string into an Hexadecimal object" do
+      hex = Hexadecimal.from_string("-EA.4")
+      hex.to_s.must_equal "-EA.4"
+      hex.to_float.must_equal -234.25
+    end
+
+    it "transform a nil into 0" do
+      hex = Hexadecimal.from_string(nil)
+      hex.to_s.must_equal "0"
+      hex.to_float.must_equal 0.0
+    end
+
+    it "transform a nil into 0 (nil as a object)" do
+      hex = nil.to_hex
+
+      hex.to_s.must_equal "0"
+      hex.to_float.must_equal 0.0
+    end
+
+    it "transform a no parseable string into 0" do
+      hex = Hexadecimal.from_string("ZZZZzz")
+
+      hex.to_s.must_equal "0"
+      hex.to_float.must_equal 0.0
+    end
+  end
+
+  describe "plus" do
+    it "sum two positive hexadecimals objects" do
+      hex1 = Hexadecimal.from_string "EA.4"
+      hex2 = Hexadecimal.from_string "EA.4"
+
+      result = hex1 + hex2
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 468.5
+      result.to_s.must_equal "1D4.8"
+    end
+
+    it "sum one hexadecimal object with a float" do
+      hex1 = Hexadecimal.from_string "EA.4"
+
+      result = hex1 + 234.25
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 468.5
+      result.to_s.must_equal "1D4.8"
+    end
+
+    it "sum one float with an hexadecimal object" do
+      hex1 = Hexadecimal.from_string "EA.4"
+
+      result = 234.25 + hex1
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 468.5
+      result.to_s.must_equal "1D4.8"
+    end
+
+    it "sum two floats (check that + is not broken)" do
+      result = 234.25 + 234.25
+
+      result.must_equal 468.5
+    end
+
+    it "sum one hexadecimal object with an integer" do
+      hex1 = Hexadecimal.from_string "EA.4"
+
+      result = hex1 + 234
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 468.25
+      result.to_s.must_equal "1D4.4"
+    end
+
+    it "sum one integer with an hexadecimal object" do
+      hex1 = Hexadecimal.from_string "EA.4"
+
+      result = 234 + hex1
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 468.25
+      result.to_s.must_equal "1D4.4"
+    end
+
+    it "sum two integer (check that + is not broken)" do
+      result = 234 + 234
+
+      result.must_equal 468
+    end
+
+    it "sum one positive hexadecimal object and one negative hexadecimal object" do
+      hex1 = Hexadecimal.from_string "EA.4"
+      hex2 = Hexadecimal.from_string "-EA.4"
+
+      result = hex1 + hex2
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 0.0
+      result.to_s.must_equal "0"
+    end
+  end
+
+  describe "minus" do
+    it "substracts two positive hexadecimals objects" do
+      hex1 = Hexadecimal.from_string "EA.4"
+      hex2 = Hexadecimal.from_string "EA.4"
+
+      result = hex1 - hex2
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 0.0
+      result.to_s.must_equal "0"
+    end
+
+    it "substracts one hexadecimal object with a float" do
+      hex1 = Hexadecimal.from_string "EA.4"
+
+      result = hex1 - 234.25
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 0.0
+      result.to_s.must_equal "0"
+    end
+
+    it "substracts one float with an hexadecimal object" do
+      hex1 = Hexadecimal.from_string "EA.4"
+
+      result = 234.25 - hex1
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 0.0
+      result.to_s.must_equal "0"
+    end
+
+    it "substracts two floats (check minus works)" do
+      result = 234.25 - 234.25
+
+      result.must_equal 0.0
+    end
+
+    it "substracts one hexadecimal object with an integer" do
+      hex1 = Hexadecimal.from_string "EA.4"
+
+      result = hex1 - 234
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 0.25
+      result.to_s.must_equal "0.4"
+    end
+
+    it "substracts one integer with an hexadecimal object" do
+      hex1 = Hexadecimal.from_string "EA.4"
+
+      result = 234 - hex1
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal -0.25
+      result.to_s.must_equal "-0.4"
+    end
+
+    it "substracts two integers (check minus works)" do
+      result = 234 - 230
+
+      result.must_equal 4
+    end
+
+    it "substracts one positive hexadecimal object and one negative hexadecimal object" do
+      hex1 = Hexadecimal.from_string "EA.4"
+      hex2 = Hexadecimal.from_string "-EA.4"
+
+      result = hex1 - hex2
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 468.5
+      result.to_s.must_equal "1D4.8"
+    end
+  end
+
+  describe "multiply" do
+    it "multiply two positive hexadecimals objects" do
+      hex1 = Hexadecimal.from_string "EA.4"
+      hex2 = Hexadecimal.from_string "EA.4"
+
+      result = hex1 * hex2
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 54873.0625
+      result.to_s.must_equal "D659.1"
+    end
+
+    it "multiply one hexadecimal object with a float" do
+      hex1 = Hexadecimal.from_string "EA.4"
+
+      result = hex1 * 234.25
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 54873.0625
+      result.to_s.must_equal "D659.1"
+    end
+
+    it "multiply one float with an hexadecimal object" do
+      hex1 = Hexadecimal.from_string "EA.4"
+
+      result = 234.25 * hex1
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 54873.0625
+      result.to_s.must_equal "D659.1"
+    end
+
+    it "multiply two floats (check multiply is not broken)" do
+      result = 234.25 * 234.25
+
+      result.must_equal 54873.0625
+    end
+
+    it "multiply one hexadecimal object with an integer" do
+      hex1 = Hexadecimal.from_string "EA.4"
+
+      result = hex1 * 1
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 234.25
+      result.to_s.must_equal "EA.4"
+    end
+
+    it "multiply one hexadecimal object with a negative integer" do
+      hex1 = Hexadecimal.from_string "EA.4"
+
+      result = hex1 * -1
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal -234.25
+      result.to_s.must_equal "-EA.4"
+
+    end
+
+    it "multiply one integer with an hexadecimal object" do
+      hex1 = Hexadecimal.from_string "EA.4"
+
+      result = -1 * hex1
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal -234.25
+      result.to_s.must_equal "-EA.4"
+    end
+
+    it "multiply two integers (check multiply is not broken)" do
+      result = 2 * 2
+
+      result.must_equal 4
+    end
+
+    it "multiply one positive hexadecimal object and one negative hexadecimal object" do
+      hex1 = Hexadecimal.from_string "EA.4"
+      hex2 = Hexadecimal.from_string "-EA.4"
+
+      result = hex1 * hex2
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal -54873.0625
+      result.to_s.must_equal "-D659.1"
+    end
+  end
+
+  describe "divide" do
+    it "divides two positive hexadecimals objects" do
+      hex1 = Hexadecimal.from_string("EA.4")
+      hex2 = Hexadecimal.from_string("EA.4")
+
+      result = hex1 / hex2
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 1
+      result.to_s.must_equal "1"
+    end
+
+    it "divides one hexadecimal object with a float" do
+      hex1 = Hexadecimal.from_string("EA.4")
+
+      result = hex1 / 234.25
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 1
+      result.to_s.must_equal "1"
+    end
+
+    it "divides one float with an hexadecimal object" do
+      hex1 = Hexadecimal.from_string("EA.4")
+
+      result = 234.25 / hex1
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 1
+      result.to_s.must_equal "1"
+    end
+
+    it "divides two floats (check divide is not broken)" do
+      result = 234.25 / 234.25
+
+      result.must_equal 1
+    end
+
+    it "divides one hexadecimal object with an integer" do
+      hex1 = Hexadecimal.from_string("EA.4")
+
+      result = hex1 / 1
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 234.25
+      result.to_s.must_equal "EA.4"
+    end
+
+    it "divides one integer with an hexadecimal object" do
+      hex1 = Hexadecimal.from_string("EA.4")
+
+      result = 1 / hex1
+
+      result.must_be_instance_of Hexadecimal
+      result.to_s.must_equal "0.0117C4FC72BFCB"
+      result.to_float.must_equal 0.004268943436499467
+    end
+
+    it "divides two integerse (check divide is not broken)" do
+      result = 1 / 2
+
+      result.must_equal 0
+    end
+
+    it "divides one positive hexadecimal object and one negative hexadecimal object" do
+      hex1 = Hexadecimal.from_string("EA.4")
+      hex2 = Hexadecimal.from_string("-EA.4")
+
+      result = hex1 / hex2
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal -1
+      result.to_s.must_equal "-1"
+    end
+
+    it "divide by zero return Infinity" do
+      hex1 = Hexadecimal.from_string "EA.4"
+
+      result = hex1 / 0
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal Float::INFINITY
+      result.to_s.must_equal "Infinity"
+    end
+  end
+
+  describe "pow" do
+    it "pows two positive hexadecimals objects" do
+      hex1 = Hexadecimal.from_string "EA.4"
+      hex2 = 2.34.to_hex
+
+      result = hex1 ** hex2
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 350792.4704875763
+      result.to_s.must_equal "55A48.7871DFB161FF7C"
+    end
+
+    it "pows two big positive hexadecimals object (should return Infinite)" do
+      hex1 = Hexadecimal.from_string "EA.4"
+      hex2 = Hexadecimal.from_string "EA.4"
+
+      result = hex1 ** hex2
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal Float::INFINITY
+      result.to_s.must_equal "Infinity"
+    end
+
+    it "pows one hexadecimal object with a float" do
+      hex1 = Hexadecimal.from_string "EA.4"
+
+      result = hex1 ** 2.34
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 350792.4704875763
+      result.to_s.must_equal "55A48.7871DFB161FF7C"
+    end
+
+    it "pows one float with an hexadecimal object" do
+      hex1 = Hexadecimal.from_string "A"
+
+      result = 2.34 ** hex1
+
+      result.must_be_instance_of Float
+      result.must_equal 4922.19227058666
+    end
+
+    it "pows two float (check pow is not broken)" do
+      result = 2.34 ** 10.0
+
+      result.must_equal 4922.19227058666
+    end
+
+    it "pows one hexadecimal object with an integer" do
+      hex1 = Hexadecimal.from_string "EA.4"
+
+      result = hex1 ** 2
+
+      result.must_be_instance_of Hexadecimal
+      result.to_float.must_equal 54873.0625
+      result.to_s.must_equal "D659.1"
+    end
+
+    it "pows one integer with an hexadecimal object" do
+      hex1 = Hexadecimal.from_string "A"
+
+      result = 2 ** hex1
+
+      result.must_be_instance_of Fixnum
+      result = 1024
+    end
+
+    it "pows one integer with an hexadecimal (with comma) object" do
+      hex1 = Hexadecimal.from_string "A.1"
+
+      result = 2 ** hex1
+
+      result.must_be_instance_of Float
+      result.must_equal 1069.3363532056717
+    end
+
+    it "pows two integer (check pot is not broken)" do
+      result = 2 ** 3
+
+      result.must_equal 8
+    end
+
+    it "pows one positive hexadecimal object and one negative hexadecimal object" do
+      hex1 = Hexadecimal.from_string "A.1"
+      hex2 = Hexadecimal.from_string "-A.2"
+
+      result = hex1 ** hex2
+
+      result.must_be_instance_of Hexadecimal
+      result.to_s.must_equal "7.67161712141568"
+      result.to_float.must_equal 7.040489085609713e-11
+    end
+  end
+end

data/spec/hex_values_spec.rb

@@ -3,72 +3,76 @@ require 'spec_helper'
 describe 'HexValues' do
   describe "float to hex" do
     it "converts 234.25 to EA.4" do
-      234.25.to_hex.must_equal "EA.4"
+      234.25.to_hex.to_s.must_equal "EA.4"
     end
 
     it "converts 1875.37 to 753.5EB851EB85" do
-      1875.37.to_hex.must_equal "753.5EB851EB851EB8"
+      1875.37.to_hex.to_s.must_equal "753.5EB851EB851EB8"
     end
 
     it "converts 5476.28 to 1564.47AE147AE1" do
-      5476.28.to_hex.must_equal "1564.47AE147AE147AE"
+      5476.28.to_hex.to_s.must_equal "1564.47AE147AE147AE"
     end
 
     it "converts 7763783.89 to 767747.E3D70A3C" do
-      7763783.89.to_hex.must_equal "767747.E3D70A3D70A3D7"
+      7763783.89.to_hex.to_s.must_equal "767747.E3D70A3D70A3D7"
     end
 
     it "converts 1 to 1" do
-      1.to_hex.must_equal "1"
+      1.to_hex.to_s.must_equal "1"
     end
 
     it "converts 10 to A" do
-      10.to_hex.must_equal "A"
+      10.to_hex.to_s.must_equal "A"
     end
 
     it "converts 0.25 to 0.4" do
-      0.25.to_hex.must_equal "0.4"
+      0.25.to_hex.to_s.must_equal "0.4"
     end
 
     it "converts 0.21 to 0.35C28F5C28F5C2" do
-      0.21.to_hex.must_equal "0.35C28F5C28F5C2"
+      0.21.to_hex.to_s.must_equal "0.35C28F5C28F5C2"
     end
 
     it "converts 0 to 0" do
-      0.to_hex.must_equal "0"
+      0.to_hex.to_s.must_equal "0"
+    end
+
+    it "converts -234.25 to -EA.4" do
+      -234.25.to_hex.to_s.must_equal "-EA.4"
     end
   end
 
   describe "float to hex with precision" do
     it "converts 234.25 to EA.4 (no matter precision)" do
-      result = 234.25.to_hex(140)
+      result = 234.25.to_hex(140).to_s
       result.must_equal "EA.4"
       num, dec = result.split('.')
       dec.size.must_equal 1
     end
 
     it "converts 1875.37 with 5 numbers after period" do
-      result = 1875.37.to_hex(5)
+      result = 1875.37.to_hex(5).to_s
       result.must_equal "753.5EB85"
       num, dec = result.split('.')
       dec.size.must_equal 5
     end
 
     it "converts 1875.37 with 50 numbers after period" do
-      result = 1875.37.to_hex(50)
+      result = 1875.37.to_hex(50).to_s
       num, dec = result.split('.')
       dec.size.must_equal 50
     end
 
     it "converts 1875.37 with 0 numbers after period" do
-      result = 1875.37.to_hex(0)
+      result = 1875.37.to_hex(0).to_s
       result.must_equal "753"
       num, dec = result.split('.')
       dec.must_be_nil
     end
 
     it "converts 1875.37 with 14 numbers after period (if a negative precision is provided)" do
-      result = 1875.37.to_hex(-1)
+      result = 1875.37.to_hex(-1).to_s
       result.must_equal "753.5EB851EB851EB8"
       num, dec = result.split('.')
       dec.size.must_equal 14
@@ -77,23 +81,23 @@ describe 'HexValues' do
 
   describe "integer to hex with precision" do
     it "converts 1 to 1 (without parameter)" do
-      1.to_hex.must_equal "1"
+      1.to_hex.to_s.must_equal "1"
     end
 
     it "converts 1 to 1 (with precision = 40)" do
-      1.to_hex(14).must_equal "1"
+      1.to_hex(14).to_s.must_equal "1"
     end
 
     it "converts 1 to 1 (with precision = 0)" do
-      1.to_hex(0).must_equal "1"
+      1.to_hex(0).to_s.must_equal "1"
     end
 
     it "converts 1 to 1 (with precision = -1)" do
-      1.to_hex(-1).must_equal "1"
+      1.to_hex(-1).to_s.must_equal "1"
     end
 
     it "converts 13 to D (with precision = 12)" do
-      13.to_hex(12).must_equal "D"
+      13.to_hex(12).to_s.must_equal "D"
     end
   end
 
@@ -133,5 +137,9 @@ describe 'HexValues' do
     it "converts an empty string to 0" do
       "".to_float.must_equal 0
     end
+
+    it "converts a no parseable string into 0" do
+      "ZZZZZZZ".to_float.must_equal 0
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hex_values
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: '0.1'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-07 00:00:00.000000000 Z
+date: 2013-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -60,8 +60,10 @@ files:
 - Rakefile
 - hex_values.gemspec
 - lib/hex_values.rb
+- lib/hex_values/hexadecimal.rb
 - lib/hex_values/version.rb
 - script/benchmark
+- spec/hex_values/hexadecimal_spec.rb
 - spec/hex_values_spec.rb
 - spec/performance_hex_values_test.rb
 - spec/spec_helper.rb
@@ -91,6 +93,7 @@ specification_version: 3
 summary: Convert any float or fixnum to the correct representation in hexadecimal,
   and convert any hexadecimal string in their corresponding float representation.
 test_files:
+- spec/hex_values/hexadecimal_spec.rb
 - spec/hex_values_spec.rb
 - spec/performance_hex_values_test.rb
 - spec/spec_helper.rb