flt 1.1.2 → 1.2.0

data/History.txt

@@ -1,3 +1,8 @@
+== 1.2.0 2010-06-15
+
+* New Features
+  - Trigonometry in radians/degrees/gradians
+
 == 1.1.2 2010-06-01
 
 * New Features

data/README.txt

@@ -567,7 +567,8 @@ EXPAND+
 
 = Roadmap
 
-* Version 1.0.0: First released version of the new flt gem.
-* Version 1.1.0: Implement the missing GDA functions:
+* Math (trigonometry) functions for DecNum & BinNum (reorganization of DecNum::Math)
+* Complex support.
+* Implement the missing GDA functions:
   rotate, shift, trim, and, or, xor, invert,
   max, min, maxmag, minmag, comparetotal, comparetotmag

data/lib/flt/float.rb

@@ -44,9 +44,13 @@ require 'singleton'
 #
 # Float::MIN  : Minimum normalized positive floating-point number
 #                  b**(emin - 1).
+#               In JRuby this is the mininimum denormal number!
 #
 # Float::ROUNDS : Addition rounds to 0: zero, 1: nearest, 2: +inf, 3: -inf, -1: unknown.
 #
+# Note: Ruby 1.9.2 Adds Float::INFINITY and Float::NAN
+#
+#
 # Additional contants defined here:
 #
 # Float::DECIMAL_DIG :  Number of decimal digits, n, such that any floating-point number can be rounded
@@ -56,11 +60,11 @@ require 'singleton'
 #                         ceil(1 + pmax * log10(b))	otherwise
 #                       DECIMAL_DIG = (MANT_DIG*Math.log(RADIX)/Math.log(10)).ceil+1
 #
-# Float::MIN_N : Minimum normalized number == MAX_D.next == MIN
+# Float::MIN_N : Minimum normalized number == MAX_D.next == MIN (not in JRuby)
 #
 # Float::MAX_D : Maximum denormal number == MIN_N.prev
 #
-# Float::MIN_D : Minimum non zero positive denormal number == 0.0.next
+# Float::MIN_D : Minimum non zero positive denormal number == 0.0.next (== MIN in JRuby)
 #
 # Float::MAX_F : Maximum significand
 class Float
@@ -110,7 +114,7 @@ class Flt::FloatContext
 
   # NaN (not a number value)
   def nan
-    0.0/0.0
+    0.0/0.0 # Ruby 1.9.2: Float::NAN
   end
 
   # zero value with specified sign
@@ -120,7 +124,7 @@ class Flt::FloatContext
 
   # infinity value with specified sign
   def infinity(sign=+1)
-    (sign < 0) ? -1.0/0.0 : 1.0/0.0
+    (sign < 0) ? -1.0/0.0 : 1.0/0.0 # Ruby 1.9.2: (sing < 0) ? -Float::INFINITY : Float::INFINITY
   end
 
   def int_radix_power(n)

data/lib/flt/math.rb

@@ -1,10 +1,5 @@
 require 'flt/dec_num'
 
-# TODO:
-# * convert arguments as Context#_convert does, to accept non DecNum arguments
-# * Better precision (currently is within about 2 ulps of the correct result)
-# * Speed optimization
-
 module Flt
   class DecNum
     module Math
@@ -18,7 +13,6 @@ module Flt
       HALF = DecNum('0.5')
 
       # Pi
-      $no_cache = false
       @@pi_cache = nil # truncated pi digits as a string
       @@pi_cache_digits = 0
       PI_MARGIN = 10
@@ -68,7 +62,10 @@ module Flt
         end
       end
 
-      # Cosine of angle in radians
+      # Cosine of an angle given in the units specified by DecNum.context.angle:
+      # * :rad for radians
+      # * :deg for degrees
+      # * :grad for gradians
       def cos(x)
         x = x.abs
         rev_sign = false
@@ -82,6 +79,7 @@ module Flt
           else
             rev_sign = !rev_sign
           end
+          x = to_rad(x)
           i, lasts, fact, num = 1, 0, 1, DecNum(x)
           s = num
           x2 = -x*x
@@ -96,7 +94,10 @@ module Flt
         return rev_sign ? (-s) : (+s)
       end
 
-      # Sine of angle in radians
+      # Sine of an angle given in the units specified by DecNum.context.angle:
+      # * :rad for radians
+      # * :deg for degrees
+      # * :grad for gradians
       def sin(x)
         sign = x.sign
         s = nil
@@ -106,7 +107,7 @@ module Flt
           x,k,pi_2 = reduce_angle2(x,2)
           sign = -sign if k>1
           x = pi_2 - x if k % 2 == 1
-          x = +x
+          x = to_rad(x)
           i, lasts, fact, num = 1, 0, 1, DecNum(x)
           s = num
           x2 = -x*x
@@ -121,6 +122,7 @@ module Flt
         return (+s).copy_sign(sign)
       end
 
+      # Tangent of an angle
       def tan(x)
         +DecNum.context do |local_context|
           local_context.precision += 2 # extra digits for intermediate steps
@@ -129,19 +131,22 @@ module Flt
         end
       end
 
-      # Arc-tangent.
+      # Arc-tangent in units specified by DecNum.context.angle
       def atan(x)
         s = nil
+        conversion = true
         DecNum.context do |local_context|
           local_context.precision += 2
           if x == 0
             return DecNum.zero
           elsif x.abs > 1
             if x.infinite?
-              s = (pi*HALF).copy_sign(x)
+              s = (quarter_cycle).copy_sign(x)
+              conversion = false
               break
             else
-              c = (pi*HALF).copy_sign(x)
+              # c = (quarter_cycle).copy_sign(x)
+              c = (HALF*pi).copy_sign(x)
               x = 1 / x
             end
           end
@@ -161,7 +166,7 @@ module Flt
             s = c - s
           end
         end
-        return +s
+        return conversion ? rad_to(s) : +s
       end
 
       def atan2(y, x)
@@ -172,19 +177,19 @@ module Flt
           if x != 0
               if y_is_real
                   a = y!=0 ? atan(y / x) : DecNum.zero
-                  a += pi.copy_sign(y) if x < 0
+                  a += half_cycle.copy_sign(y) if x < 0
                   return a
               elsif abs_y == abs_x
                   x = DecNum(1).copy_sign(x)
                   y = DecNum(1).copy_sign(y)
-                  return pi * (2 - x) / (4 * y)
+                  return half_cycle * (2 - x) / (4 * y)
               end
           end
 
           if y != 0
               return atan(DecNum.infinity(y.sign))
           elsif x < 0
-              return pi.copy_sign(x)
+              return half_cycle.copy_sign(x)
           else
               return DecNum.zero
           end
@@ -195,11 +200,11 @@ module Flt
         return DecNum.context.exception(Num::InvalidOperation, 'asin needs -1 <= x <= 1') if x.abs > 1
 
           if x == -1
-              return -pi*HALF
+              return -quarter_cycle
           elsif x == 0
               return DecNum.zero
           elsif x == 1
-              return pi*HALF
+              return quarter_cycle
           end
 
           DecNum.context do |local_context|
@@ -212,29 +217,21 @@ module Flt
 
       def acos(x)
 
-        # We can compute acos(x) = pi/2 - asin(x)
-        # but we must take care with x near 1, where that formula would cause loss of precision
-
         return DecNum.context.exception(Num::InvalidOperation, 'acos needs -1 <= x <= 2') if x.abs > 1
 
         if x == -1
-            return pi
+            return half_cycle
         elsif x == 0
-            return +DecNum.context(:precision=>DecNum.context.precision+3){pi*HALF}
+            return quarter_cycle
         elsif x == 1
             return DecNum.zero
         end
 
-        # some identities:
-        #   acos(x) = pi/2 - asin(x) # (but this losses accuracy near x=+1)
-        #   acos(x) = pi/2 - atan(x/(1-x*x).sqrt) # this too
-        #   acos(x) = asin((1-x*x).sqrt) for x>=0; for x<=0  acos(x) = pi/2 - asin((1-x*x).sqrt)
-
         if x < HALF
           DecNum.context do |local_context|
             local_context.precision += 3
             x = x/(1-x*x).sqrt
-            x = pi*HALF - atan(x)
+            x = quarter_cycle - atan(x)
           end
         else
           # valid for x>=0
@@ -255,7 +252,7 @@ module Flt
         end
       end
 
-      # TODO: degrees mode or radians/degrees conversion
+      # TODO: add angular units to context; add support for degrees
 
       def pi2(decimals=nil)
         decimals ||= DecNum.context.precision
@@ -298,34 +295,7 @@ module Flt
         end
 
         def modtwopi(x)
-          return +DecNum.context(:precision=>DecNum.context.precision*3){x.modulo(pi2)}
-          # This seems to be slower and less accurate:
-          # prec = DecNum.context.precision
-          # pi_2 = pi2(prec*2)
-          # return x if x < pi_2
-          # ex = x.fractional_exponent
-          # DecNum.context do |local_context|
-          #   # x.modulo(pi_2)
-          #   local_context.precision *= 2
-          #   if ex > prec
-          #     # consider exponent separately
-          #     fd = nil
-          #     excess = ex - prec
-          #     x = x.scaleb(prec-ex)
-          #     # now obtain 2*prec digits from inv2pi after the initial excess digits
-          #     digits = nil
-          #     inv_2pi = inv2pi(local_context.precision+excess)
-          #     DecNum.context do |extended_context|
-          #       extended_context.precision += excess
-          #       digits = (inv2pi.scaleb(excess)).fraction_part
-          #     end
-          #     x *= digits*pi_2
-          #   end
-          #   # compute the fractional part of the division by 2pi
-          #   inv_2pi ||= inv2pi
-          #   x = pi_2*((x*inv2pi).fraction_part)
-          # end
-          # +x
+          return +DecNum.context(:precision=>DecNum.context.precision*3){x.modulo(one_cycle)}
         end
 
         # Reduce angle to [0,2Pi)
@@ -338,12 +308,123 @@ module Flt
           # we could reduce first to pi*2 to avoid the mod k0 operation
           k,r,divisor = DecNum.context do
             DecNum.context.precision *= 3
-            m = k0.nil? ? pi2 : pi/k0
+            m = k0.nil? ? one_cycle : half_cycle/k0
             a.divmod(m)+[m]
           end
           [r, k.modulo(k0*2).to_i, divisor]
         end
 
+        def one_cycle
+          case DecNum.context.angle
+          when :rad
+            pi2
+          when :deg
+            DecNum(360)
+          when :grad
+            DecNum(400)
+          end
+        end
+
+        def half_cycle
+          case DecNum.context.angle
+          when :rad
+            pi
+          when :deg
+            DecNum(180)
+          when :grad
+            DecNum(200)
+          end
+        end
+
+        def quarter_cycle
+          case DecNum.context.angle
+          when :rad
+            HALF*pi
+          when :deg
+            DecNum(90)
+          when :grad
+            DecNum(100)
+          end
+        end
+
+        def to_rad(x)
+          case DecNum.context.angle
+          when :rad
+            +x
+          else
+            +DecNum.context(:precision=>DecNum.context.precision+3){x*pi/half_cycle}
+          end
+        end
+
+        def to_deg(x)
+          case DecNum.context.angle
+          when :deg
+            +x
+          else
+            +DecNum.context(:precision=>DecNum.context.precision+3){x*DecNum(180)/half_cycle}
+          end
+        end
+
+        def to_grad(x)
+          case DecNum.context.angle
+          when :deg
+            +x
+          else
+            +DecNum.context(:precision=>DecNum.context.precision+3){x*DecNum(200)/half_cycle}
+          end
+        end
+
+        def to_angle(angular_units, x)
+          return +x if angular_units == DecNum.context.angle
+          case angular_units
+          when :rad
+            to_rad(x)
+          when :deg
+            to_deg(x)
+          when :grad
+            to_grad(x)
+          end
+        end
+
+        def rad_to(x)
+          case DecNum.context.angle
+          when :rad
+            +x
+          else
+            +DecNum.context(:precision=>DecNum.context.precision+3){x*half_cycle/pi}
+          end
+        end
+
+        def deg_to(x)
+          case DecNum.context.angle
+          when :deg
+            +x
+          else
+            +DecNum.context(:precision=>DecNum.context.precision+3){x*half_cycle/DecNum(180)}
+          end
+        end
+
+        def grad_to(x)
+          case DecNum.context.angle
+          when :grad
+            +x
+          else
+            +DecNum.context(:precision=>DecNum.context.precision+3){x*half_cycle/DecNum(200)}
+          end
+        end
+
+        def angle_to(x, angular_units)
+          return +x if angular_units == DecNum.context.angle
+          case angular_units
+          when :rad
+            rad_to(x)
+          when :deg
+            deg_to(x)
+          when :grad
+            grad_to(x)
+          end
+        end
+
       #end
 
     end # Math

data/lib/flt/num.rb

@@ -408,6 +408,7 @@ class Num < Numeric
         @flags = Num::Flags()
         @coercible_type_handlers = num_class.base_coercible_types.dup
         @conversions = num_class.base_conversions.dup
+        @angle = :rad # angular units: :rad (radians) / :deg (degrees) / :grad (gradians)
       end
       assign options.first
 
@@ -476,7 +477,7 @@ class Num < Numeric
       @num_class.int_div_radix_power(x,n)
     end
 
-    attr_accessor :rounding, :emin, :emax, :flags, :traps, :ignored_flags, :capitals, :clamp
+    attr_accessor :rounding, :emin, :emax, :flags, :traps, :ignored_flags, :capitals, :clamp, :angle
 
     # TODO: consider the convenience of adding accessors of this kind:
     # def rounding(new_rounding=nil)
@@ -593,6 +594,7 @@ class Num < Numeric
         @capitals = options[:capitals ] unless options[:capitals ].nil?
         @clamp = options[:clamp ] unless options[:clamp ].nil?
         @exact = options[:exact ] unless options[:exact ].nil?
+        @angle = options[:angle ] unless options[:angle ].nil?
         update_precision
       end
     end
@@ -615,6 +617,7 @@ class Num < Numeric
       @exact = other.exact
       @coercible_type_handlers = other.coercible_type_handlers.dup
       @conversions = other.conversions.dup
+      @angle = other.angle
     end
 
     def dup
@@ -971,7 +974,7 @@ class Num < Numeric
     def inspect
       class_name = self.class.to_s.split('::').last
       "<#{class_name}:\n" +
-      instance_variables.map { |v| "  #{v}: #{eval(v).inspect}"}.join("\n") +
+      instance_variables.map { |v| "  #{v}: #{instance_variable_get(v).inspect}"}.join("\n") +
       ">\n"
     end
 
@@ -4151,7 +4154,8 @@ class Num < Numeric
             :traps=>[DivisionByZero, Overflow, InvalidOperation],
             :ignored_flags=>[],
             :capitals=>true,
-            :clamp=>true
+            :clamp=>true,
+            :angle=>:rad
           )
 
         end

data/lib/flt/version.rb

@@ -1,8 +1,8 @@
 module Flt
   module VERSION #:nodoc:
     MAJOR = 1
-    MINOR = 1
-    TINY  = 2
+    MINOR = 2
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/test_basic.rb

@@ -1,53 +1,59 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'helper.rb'))
 
-def exp(x,c=nil)
-  i, lasts, s, fact, num = 0, 0, 1, 1, 1
-  DecNum.local_context(c) do
-    # result context
-    DecNum.local_context do |context|
-      # working context
-      context.precision += 2
-      context.rounding = DecNum::ROUND_HALF_EVEN
-      while s != lasts
-        lasts = s
-        i += 1
-        fact *= i
-        num *= x
-        s += num / fact
+module TestFunctions
+
+  module_function
+
+  def exp(x,c=nil)
+
+    i, lasts, s, fact, num = 0, 0, 1, 1, 1
+    DecNum.local_context(c) do
+      # result context
+      DecNum.local_context do |context|
+        # working context
+        context.precision += 2
+        context.rounding = DecNum::ROUND_HALF_EVEN
+        while s != lasts
+          lasts = s
+          i += 1
+          fact *= i
+          num *= x
+          s += num / fact
+        end
       end
+      +s
     end
-    +s
   end
-end
 
-def exp1(x, c=nil)
-  return DecNum(BigDecimal("NaN")) if x.infinite? || x.nan?
-  y = nil
-  ext = 2
-  DecNum.local_context(c) do |context|
-    n = (context.precision += ext)
-
-    one  = DecNum("1")
-    x1 = one
-    y  = one
-    d  = y
-    z  = one
-    i  = 0
-    while d.nonzero? && ((m = n - (y.fractional_exponent - d.fractional_exponent).abs) > 0)
-      m = ext if m < ext
-      x1  *= x
-      i += 1
-      z *= i
-
-      #d  = x1.divide(z,:precision=>m)
-      context.precision = m
-      d = x1/z
-      context.precision = n
-
-      y += d
+  def exp1(x, c=nil)
+    return DecNum(BigDecimal("NaN")) if x.infinite? || x.nan?
+    y = nil
+    ext = 2
+    DecNum.local_context(c) do |context|
+      n = (context.precision += ext)
+
+      one  = DecNum("1")
+      x1 = one
+      y  = one
+      d  = y
+      z  = one
+      i  = 0
+      while d.nonzero? && ((m = n - (y.fractional_exponent - d.fractional_exponent).abs) > 0)
+        m = ext if m < ext
+        x1  *= x
+        i += 1
+        z *= i
+
+        #d  = x1.divide(z,:precision=>m)
+        context.precision = m
+        d = x1/z
+        context.precision = n
+
+        y += d
+      end
     end
+    return +y
   end
-  return +y
 end
 
 def return_from_local_context
@@ -324,10 +330,10 @@ class TestBasic < Test::Unit::TestCase
     DecNum.context.precision = 100
     DecNum.context.rounding = :half_even
     e_100 = "2.718281828459045235360287471352662497757247093699959574966967627724076630353547594571382178525166427"
-    assert_equal e_100, exp(DecNum(1)).to_s
-    assert_equal DecNum(e_100), exp(DecNum(1))
-    assert_equal e_100, exp1(DecNum(1)).to_s
-    assert_equal DecNum(e_100), exp1(DecNum(1))
+    assert_equal e_100, TestFunctions.exp(DecNum(1)).to_s
+    assert_equal DecNum(e_100), TestFunctions.exp(DecNum(1))
+    assert_equal e_100, TestFunctions.exp1(DecNum(1)).to_s
+    assert_equal DecNum(e_100), TestFunctions.exp1(DecNum(1))
   end
 
   def test_special

data/test/test_bin.rb

@@ -23,7 +23,7 @@ class TestBin < Test::Unit::TestCase
     assert_equal 0.1, BinNum('0.1', :fixed)
 
     assert_equal Float::MAX, BinNum.context.maximum_finite
-    assert_equal Float::MIN, BinNum.context.minimum_normal
+    assert_equal Float::MIN_N, BinNum.context.minimum_normal
 
     numbers = %w{
       0.123437

data/test/test_dectest.rb

@@ -125,7 +125,8 @@ class TestBasic < Test::Unit::TestCase
 
         File.open(fn,'r') do |file|
           file.each_line do |line|
-            next if line[0,2]=='--' || line.strip.empty?
+            line = line.split('--').first.strip if line.include?('--')
+            next if line.strip.empty?
 
             if line.include?(' -> ')
               # test
@@ -148,7 +149,7 @@ class TestBasic < Test::Unit::TestCase
               if funct
                 # do test
                 msg = "  Test #{id}: #{funct}(#{valstemp.join(',')}) = #{ans}"
-                File.open('dectests.txt','a'){|f| f.puts msg}
+                #File.open('dectests.txt','a'){|f| f.puts msg}
                 expected = result = result_flags = nil
                 DecNum.local_context do |context|
                   context.flags.clear!

data/test/test_trig.rb

@@ -7,70 +7,101 @@ class TestTrig < Test::Unit::TestCase
 
 
   def setup
-    @data12 = {}
-    [:sin, :cos, :tan, :asin, :acos, :atan].each do |f|
-      @data12[f] = File.read(File.join(File.dirname(__FILE__), "trigtest/#{f}12.txt")).split("\n").map do |line|
-        line.split.map{|x| Flt::DecNum(x)}
+    @data = {}
+    Dir[File.join(File.dirname(__FILE__), "trigtest/*.txt")].each do |fn|
+      if File.basename(fn) =~ /\A([a-z]+)(\d+)_(\d+)_([a-z]+)\.txt\Z/
+        method = $1.to_sym
+        radix = $2.to_i
+        prec = $3.to_i
+        angle = $4.to_sym
+        @data[radix] ||= {}
+        @data[radix][angle] ||= {}
+        @data[radix][angle][prec] ||= {}
+        @data[radix][angle][prec][method] = File.read(fn).split("\n").map do |line|
+          line.split.map{|x| Flt::DecNum(x)}
+        end
       end
     end
   end
 
-  def check(f)
-    DecNum.context(:precision=>12) do
-      data = @data12[f]
-      data.each do |x, result|
-        assert_equal result, DecNum::Math.send(f, x), "#{f}(#{x})==#{result}"
+  def check(f, radix=10, angle=:rad)
+    class_num = Num[radix]
+    @data[radix][angle].keys.each do |prec|
+      class_num.context(:precision=>prec, :angle=>angle) do
+        class_num.context.traps[DecNum::DivisionByZero] = false
+        data = @data[radix][angle][prec][f]
+        data.each do |x, result|
+          assert_equal result, class_num::Math.send(f, x), "#{f}(#{x})==#{result} [#{radix} #{angle} #{prec}]"
+        end
       end
     end
   end
 
-  def check_relaxed(f, ulps=2)
-    DecNum.context(:precision=>12) do
-      data = @data12[f]
-      data.each do |x, result|
-        y = DecNum::Math.send(f, x)
-        err_ulps = (y-result).abs/result.ulp
-        assert err_ulps<=ulps, "#{f}(#{x})==#{result} to within #{ulps} ulps; error: #{err_ulps} ulps (#{y}) [#{DecNum.context.precision}]"
+  def check_relaxed(f, radix=10, angle=:rad, ulps=1)
+    class_num = Num[radix]
+    @data[radix][angle].keys.each do |prec|
+      class_num.context(:precision=>prec, :angle=>angle) do
+        class_num.context.traps[DecNum::DivisionByZero] = false
+        data = @data[radix][angle][prec][f]
+        data.each do |x, result|
+          y = class_num::Math.send(f, x)
+          if result.special?
+            assert_equal result, y, "#{f}(#{x})==#{result} [#{radix} #{angle} #{prec}]"
+          else
+            err_ulps = (y-result).abs/result.ulp
+            assert err_ulps<=ulps, "#{f}(#{x})==#{result} to within #{ulps} ulps; error: #{err_ulps} ulps (#{y}) [#{radix} #{angle} #{prec}]"
+          end
+        end
       end
     end
   end
 
-
-  # def test_trig
-  #   DecNum.context(:precision=>12) do
-  #     @data12.keys.each do |f|
-  #       data = @data12[f]
-  #       data.each do |x, result|
-  #         assert_equal result, DecNum::Math.send(f, x), "#{f}(#{x})==#{result}"
-  #       end
-  #     end
-  #   end
-  # end
-
-  # separate tests per function
-
   def test_sin
-    check_relaxed :sin
+    check :sin, 10, :rad
   end
 
   def test_cos
-    check_relaxed :cos
+    check :cos, 10, :rad
   end
 
   def test_tan
-    check_relaxed :tan
+    check_relaxed :tan, 10, :rad
   end
 
   def test_asin
-    check_relaxed :asin
+    check_relaxed :asin, 10, :rad
   end
 
   def test_acos
-    check_relaxed :acos
+    check_relaxed :acos, 10, :rad
   end
 
   def test_atan
-    check_relaxed :atan
+    check_relaxed :atan, 10, :rad
+  end
+
+  def test_sin_deg
+    check_relaxed :sin, 10, :deg
+  end
+
+  def test_cos_deg
+    check_relaxed :cos, 10, :deg
+  end
+
+  def test_tan_deg
+    check_relaxed :tan, 10, :deg
+  end
+
+  def test_asin_deg
+    check_relaxed :asin, 10, :deg
+  end
+
+  def test_acos_deg
+    check_relaxed :acos, 10, :deg
+  end
+
+  def test_atan_deg
+    check_relaxed :atan, 10, :deg
   end
 
 end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: flt
 version: !ruby/object:Gem::Version 
-  hash: 23
   prerelease: false
   segments: 
   - 1
-  - 1
   - 2
-  version: 1.1.2
+  - 0
+  version: 1.2.0
 platform: ruby
 authors: 
 - Javier Goizueta
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-01 00:00:00 +02:00
+date: 2010-06-15 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,7 +25,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 9
         segments: 
         - 2
         - 1
@@ -125,7 +123,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -134,7 +131,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"