ieee-fpu 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1"
+  gem "jeweler", "~> 1.8.4"
+  gem "flt"
+end
+

data/Gemfile.lock

@@ -0,0 +1,35 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.2.8)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    flt (1.3.0)
+    git (1.2.5)
+    i18n (0.6.1)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.5)
+    multi_json (1.3.6)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    shoulda (3.1.1)
+      shoulda-context (~> 1.0)
+      shoulda-matchers (~> 1.2)
+    shoulda-context (1.0.0)
+    shoulda-matchers (1.3.0)
+      activesupport (>= 3.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1)
+  flt
+  jeweler (~> 1.8.4)
+  rdoc (~> 3.12)
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Javier Goizueta
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,95 @@
+= ieee-fpu
+
+Ruby gem for the control of IEEE compliant FPUs rounding mode and precision (if available).
+
+IEEE_FPU has two writeable properties:
+
+* rounding which has values :even, :up, :down and :zero
+* precision with values :single, :double and :extended
+
+The latter property is not available in all IEEE FPUs
+
+The scope method can be used to set up an scope in which
+FPU properties are modified; when the scope is exited
+the FPU state is restored.
+
+Examples:
+
+   puts IEEE_FPU.rounding                # -> even
+   puts "%.20f"%(1.0+Float::EPSILON/2)   # -> 1.00000000000000000000
+   IEEE_FPU.scope {
+     IEEE_FPU.rounding = :down
+     puts IEEE_FPU.rounding              # -> down
+     puts "%.20f"%(1.0+Float::EPSILON/2) # -> 1.00000000000000000000
+   }
+   IEEE_FPU.scope { |fpu|
+     fpu.rounding = :up
+     puts IEEE_FPU.rounding              # -> up
+     puts "%.20f"%(1.0+Float::EPSILON/2) # -> 1.00000000000000022204
+   }
+   puts IEEE_FPU.rounding                # -> even
+   puts "%.20f"%(1.0+Float::EPSILON/2)   # -> 1.00000000000000000000
+
+   expr = '(3.2-2.0)-1.2'
+   IEEE_FPU.scope {
+     IEEE_FPU.precision = :single           # -> 0.0
+     puts eval(expr)
+   }
+   IEEE_FPU.scope {
+     IEEE_FPU.precision = :double
+     puts eval(expr)                        # -> 2.22044604925031e-16
+   }
+
+Note: IEEE_FPU.precision=:extended has a very limited influence in Ruby
+because all results are casted to Float (double) values.
+Its effect is more noticeable in C/C++ extensions.
+
+FPU parameters can be assigneed passign a hash to the scope method:
+   IEEE_FPU.scope(:precision=>:single) {
+     puts eval(expr)
+   }
+
+An array can be passed for one (only one) of the parameters;
+the block will be repeated with every value of the parameter
+and the results will be collected in an array.
+
+For example this checks the result of an expression in all
+the rounding modes:
+
+  puts IEEE_FPU.scope(:rounding=>[:even,:up,:down,:zero]) {
+    1.0 + Float::EPSILON/2
+  }.inspect
+
+Different parameters can be passed to each call of the block
+by assigning an array to :parameters
+
+For example, interval arithmetic could be implementes like this:
+
+  def sum_intervals(i1,i2)
+    IEEE_FPU.scope(:rounding=>[:down,:up],:parameters=>[0,1]) do |fpu,i|
+      i1[i]+i2[i]
+    end
+  end
+  i = sum_intervals([1.0]*2, [Float::EPSILON/2]*2)
+
+== TODO
+
+* Gem with the C extension; avoid compiling under mswin32 if possible (the extension is not needed)
+* Binary gems for mingw32
+* Rename IEEE_FPU, review API design
+* Flt interoperatibility
+
+== Contributing to ieee-fpu
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2007, 2012 Javier Goizueta. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "ieee-fpu"
+  gem.homepage = "http://github.com/jgoizueta/ieee-fpu"
+  gem.license = "MIT"
+  gem.summary = %Q{Control of IEEE compliant FPUs rounding mode and precision}
+  gem.description = %Q{Control of IEEE compliant FPUs rounding mode and precision}
+  gem.email = "jgoizueta@gmail.com"
+  gem.authors = ["Javier Goizueta"]
+  # dependencies defined in Gemfile
+  gem.extensions = ['ext/extconf.rb']
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ieee-fpu #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/ext/extconf.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/ruby
+require 'mkmf'
+
+fenv = control = false
+
+if have_header('fenv.h')
+  fenv = true
+  #$defs.push "IEEE_FPU_FENV=1"
+  have_func('fesetprec','fenv.h')
+end
+
+if have_header('fpu_control.h')
+  control = true
+  #$defs.push "IEEE_FPU_CONTROL=1"
+end
+create_makefile("ieee_fpu_control") if fenv || control
+

data/ext/ieee_fpu_control.c

@@ -0,0 +1,121 @@
+#include <ruby.h>
+
+#if HAVE_FENV_H
+#include <fenv.h>
+
+static VALUE mIEEE_FPU_fegetround(VALUE self)
+{
+  return UINT2NUM(fegetround());
+}
+
+/*
+ * Set the FPU's rounding mode.
+ */
+static VALUE mIEEE_FPU_fesetround(VALUE self, VALUE mode)
+{
+  fesetround(NUM2UINT(mode));
+  return UINT2NUM(fegetround());
+}
+
+#if HAVE_FESETPREC
+static VALUE mIEEE_FPU_fegetprec(VALUE self)
+{
+  return UINT2NUM(fegetprec());
+}
+static VALUE mIEEE_FPU_fesetprec(VALUE self, VALUE prec)
+{
+  fesetprec(NUM2UINT(prec));
+  return UINT2NUM(fegetprec());
+}
+#endif
+
+
+#endif 
+
+
+#if HAVE_FPU_CONTROL_H
+
+#include <fpu_control.h>
+
+static VALUE mIEEE_FPU_fpu_getround(VALUE self)
+{
+  fpu_control_t mask = (_FPU_RC_NEAREST|_FPU_RC_DOWN|_FPU_RC_UP|_FPU_RC_ZERO);
+  fpu_control_t c;
+  _FPU_GETCW(c);  
+  return UINT2NUM(c & mask);
+}
+
+static VALUE mIEEE_FPU_fpu_setround(VALUE self, VALUE mode)
+{
+  fpu_control_t mask = (_FPU_RC_NEAREST|_FPU_RC_DOWN|_FPU_RC_UP|_FPU_RC_ZERO);
+  fpu_control_t c, new_c;
+  _FPU_GETCW(c);  
+  new_c = c;
+  new_c &= ~mask;
+  new_c |= NUM2UINT(mode);
+  _FPU_SETCW(new_c);  
+  return UINT2NUM(c & mask);
+}
+
+static VALUE mIEEE_FPU_fpu_getprec(VALUE self)
+{
+  fpu_control_t mask = (_FPU_EXTENDED|_FPU_DOUBLE|_FPU_SINGLE);
+  fpu_control_t c;
+  _FPU_GETCW(c);  
+  return UINT2NUM(c & mask);
+}
+static VALUE mIEEE_FPU_fpu_setprec(VALUE self, VALUE prec)
+{
+  fpu_control_t mask = (_FPU_EXTENDED|_FPU_DOUBLE|_FPU_SINGLE);
+  fpu_control_t c, new_c;
+  _FPU_GETCW(c);  
+  new_c = c;
+  new_c &= ~mask;
+  new_c |= NUM2UINT(prec);
+  _FPU_SETCW(new_c);  
+  return UINT2NUM(c & mask);
+}
+
+#endif
+
+static VALUE mIEEE_FPU;
+
+void Init_ieee_fpu_control() {
+  mIEEE_FPU = rb_define_module("IEEE_FPU");
+
+  #if HAVE_FPU_CONTROL_H
+  rb_define_const(mIEEE_FPU, "FPU_RC_NEAREST", UINT2NUM(_FPU_RC_NEAREST));
+  rb_define_const(mIEEE_FPU, "FPU_RC_DOWN", UINT2NUM(_FPU_RC_DOWN));
+  rb_define_const(mIEEE_FPU, "FPU_RC_UP", UINT2NUM(_FPU_RC_UP));
+  rb_define_const(mIEEE_FPU, "FPU_RC_ZERO", UINT2NUM(_FPU_RC_ZERO));
+
+  rb_define_module_function(mIEEE_FPU, "fpu_getround", mIEEE_FPU_fpu_getround, 0);
+  rb_define_module_function(mIEEE_FPU, "fpu_setround", mIEEE_FPU_fpu_setround, 1);
+  
+  rb_define_const(mIEEE_FPU, "FPU_EXTENDED", UINT2NUM(_FPU_EXTENDED));
+  rb_define_const(mIEEE_FPU, "FPU_DOUBLE", UINT2NUM(_FPU_DOUBLE));
+  rb_define_const(mIEEE_FPU, "FPU_SINGLE", UINT2NUM(_FPU_SINGLE));
+
+  rb_define_module_function(mIEEE_FPU, "fpu_getprec", mIEEE_FPU_fpu_getprec, 0);
+  rb_define_module_function(mIEEE_FPU, "fpu_setprec", mIEEE_FPU_fpu_setprec, 1);
+  #endif
+
+  #if HAVE_FENV_H
+  rb_define_const(mIEEE_FPU, "FE_DOWNWARD", UINT2NUM(FE_DOWNWARD));
+  rb_define_const(mIEEE_FPU, "FE_TONEAREST", UINT2NUM(FE_TONEAREST));
+  rb_define_const(mIEEE_FPU, "FE_TOWARDZERO", UINT2NUM(FE_TOWARDZERO));
+  rb_define_const(mIEEE_FPU, "FE_UPWARD", UINT2NUM(FE_UPWARD));
+
+  rb_define_module_function(mIEEE_FPU, "fegetround", mIEEE_FPU_fegetround, 0);
+  rb_define_module_function(mIEEE_FPU, "fesetround", mIEEE_FPU_fesetround, 1);
+  
+  #if HAVE_FESETPREC
+  rb_define_const(mIEEE_FPU, "FE_FLTPREC", UINT2NUM(FE_FLTPREC));
+  rb_define_const(mIEEE_FPU, "FE_DBLPREC", UINT2NUM(FE_DBLPREC));
+  rb_define_const(mIEEE_FPU, "FE_LDBLPREC", UINT2NUM(FE_LDBLPREC));
+
+  rb_define_module_function(mIEEE_FPU, "fegetprec", mIEEE_FPU_fegetprec, 0);
+  rb_define_module_function(mIEEE_FPU, "fesetprec", mIEEE_FPU_fesetprec, 1);
+  #endif
+  #endif
+}

data/ieee-fpu.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "ieee-fpu"
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Javier Goizueta"]
+  s.date = "2012-09-28"
+  s.description = "Control of IEEE compliant FPUs rounding mode and precision"
+  s.email = "jgoizueta@gmail.com"
+  s.extensions = ["ext/extconf.rb"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "ext/extconf.rb",
+    "ext/ieee_fpu_control.c",
+    "ieee-fpu.gemspec",
+    "lib/ieee-fpu.rb",
+    "test/helper.rb",
+    "test/test_ieee-fpu.rb"
+  ]
+  s.homepage = "http://github.com/jgoizueta/ieee-fpu"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.23"
+  s.summary = "Control of IEEE compliant FPUs rounding mode and precision"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_development_dependency(%q<flt>, [">= 0"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+      s.add_dependency(%q<flt>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+    s.add_dependency(%q<flt>, [">= 0"])
+  end
+end
+

data/lib/ieee-fpu.rb

@@ -0,0 +1,424 @@
+# IEEE_FPU -- IEEE FPU control
+# Javier Goizueta 2007
+
+begin
+  require 'ieee_fpu_control'
+  IEEE_FPU_FENV = IEEE_FPU.respond_to?(:fesetround)
+  IEEE_FPU_CONTROL = IEEE_FPU.respond_to?(:fpu_setprec)
+  rescue LoadError
+  IEEE_FPU_FENV = false
+  IEEE_FPU_CONTROL = false
+end
+
+unless IEEE_FPU_FENV || IEEE_FPU_CONTROL
+
+require 'Win32API'
+
+# Control of IEEE compliant FPUs rounding mode
+# and precision (if available).
+# IEEE_FPU has two writeable properties:
+# * rounding which has values :even, :up, :down and :zero
+# * precision with values :single, :double and :extended
+# The latter property is not available in all IEEE FPUs
+# The scope method can be used to set up an scope in which
+# FPU properties are modified; when the scope is exited
+# the FPU state is restored.
+# Examples:
+#   puts IEEE_FPU.rounding                # -> even
+#   puts "%.20f"%(1.0+Float::EPSILON/2)   # -> 1.00000000000000000000
+#   IEEE_FPU.scope {
+#     IEEE_FPU.rounding = :down
+#     puts IEEE_FPU.rounding              # -> down
+#     puts "%.20f"%(1.0+Float::EPSILON/2) # -> 1.00000000000000000000
+#   }
+#   IEEE_FPU.scope { |fpu|
+#     fpu.rounding = :up
+#     puts IEEE_FPU.rounding              # -> up
+#     puts "%.20f"%(1.0+Float::EPSILON/2) # -> 1.0000000000000002220
+#   }
+#   puts IEEE_FPU.rounding                # -> even
+#   puts "%.20f"%(1.0+Float::EPSILON/2)   # -> 1.00000000000000000000
+#
+#   expr = '(3.2-2.0)-1.2'
+#   IEEE_FPU.scope {
+#     IEEE_FPU.precision = :single           # -> 0.0
+#     puts eval(expr)
+#   }
+#   IEEE_FPU.scope {
+#     IEEE_FPU.precision = :double
+#     puts eval(expr)                        # -> 2.22044604925031e-16
+#   }
+#
+# Note: IEEE_FPU.precision=:extended has a very limited influence in Ruby
+# because all results are casted to Float (double) values.
+# Its effect is more noticeable in C/C++ extensions.
+
+# FPU parameters can be assigneed passign a hash to the scope method:
+#   IEEE_FPU.scope(:precision=>:single) {
+#     puts eval(expr)
+#   }
+# An array can be passed for one (only one) of the parameters;
+# the block will be repeated with every value of the parameter
+# and the results will be collected in an array.
+# For example this checks the result of an expression in all
+# the rounding modes:
+#  puts IEEE_FPU.scope(:rounding=>[:even,:up,:down,:zero]) {
+#    1.0 + Float::EPSILON/2
+#  }.inspect
+#
+# Different parameters can be passed to each call of the block
+# by assigning an array to :parameters
+# For example, interval arithmetic could be implementes like this:
+#  def sum_intervals(i1,i2)
+#    IEEE_FPU.scope(:rounding=>[:down,:up],:parameters=>[0,1]) do |fpu,i|
+#      i1[i]+i2[i]
+#    end
+#  end
+#  i = sum_intervals([1.0]*2, [Float::EPSILON/2]*2)
+
+
+module IEEE_FPU
+
+  class Error < StandardError
+  end
+
+  def self.get_status
+    Controlfp.call(0,0)
+  end
+  def self.set_status(s)
+    Controlfp.call(s,MCW_DN|MCW_EM|MCW_IC|MCW_RC|MCW_PC)
+  end
+  def self.scope(assignments={})
+    v = nil
+    s = get_status
+    prc = assignments[:precision]
+    rnd = assignments[:rounding]
+    self.precision = prc if prc && !(Array===prc)
+    self.rounding =rnd if rnd && !(Array===rnd)
+    if Array===prc
+      param = assignments[:parameters] || [nil]*prc.size
+      v = []
+      i = 0
+      prc.each do |p|
+        self.precision = p
+        v << yield(self, param[i])
+        i += 1
+      end
+    elsif Array===rnd
+      param = assignments[:parameters] || [nil]*rnd.size
+      v = []
+      i = 0
+      rnd.each do |r|
+        self.rounding = r
+        v << yield(self, param[i])
+        i += 1
+      end
+    else
+      v = yield(self)
+    end
+    v
+    ensure
+      set_status s
+  end
+
+  def self.precision
+    v = get_status & MCW_PC
+    p = nil
+    case v
+      when PC_24
+        p = :single
+      when PC_53
+        p = :double
+      when PC_64
+        p = :extended
+    end
+    p
+  end
+  def self.precision=(p)
+    v = nil
+    case p
+      when :single, 24
+        v = PC_24
+      when :double, 53
+        v = PC_53
+      when :extended, 64, 112
+        v = PC_64
+      else
+        raise Error, "Invalid precision #{p.inspect}"
+    end
+    Controlfp.call(v,MCW_PC) unless v.nil?
+    p
+  end
+
+  def self.rounding
+    v = get_status & MCW_RC
+    r = nil
+    case v
+      when RC_UP
+        r = :up
+      when RC_DOWN
+        r = :down
+      when RC_CHOP
+        r = :zero
+      when RC_NEAR
+        r = :even
+    end
+    r
+  end
+
+  def self.rounding=(r)
+    v = nil
+    case r
+      when :up, :plus_infinity, :positive_infinity
+        v = RC_UP
+      when :down, :minus_inifinity, :negative_infinity
+        v = RC_DOWN
+      when :zero, :truncate, :chop
+        v = RC_CHOP
+      when :even, :near, :unbiased
+        v = RC_NEAR
+      else
+        raise Error, "Invalid rounding mode #{r}"
+      end
+    Controlfp.call(v,MCW_RC) unless v.nil?
+    r
+  end
+
+  def self.supported_precisions
+    [:single, :double, :extended]
+  end
+
+
+    Controlfp = Win32API.new('msvcrt', '_controlfp', 'II', 'I')
+  MCW_DN = 0x03000000 # Denormal control mask
+    DN_SAVE  = 0x00000000
+    DN_FLUSH = 0x01000000
+  MCW_EM = 0x0008001F # Interrupt exception mask
+    EM_INVALID =    0x00000010
+    EM_DENORMAL =   0x00080000
+    EM_ZERODIVIDE = 0x00000008
+    EM_OVERFLOW =   0x00000004
+    EM_UNDERFLOW =  0x00000002
+    EM_INEXACT =    0x00000001
+  MCW_IC = 0x00040000 # Infinity control mask
+    IC_AFFINE     = 0x00040000
+    IC_PROJECTIVE = 0x00000000
+  MCW_RC = 0x00000300 # Rounding control mask
+    RC_CHOP = 0x00000300
+    RC_UP   = 0x00000200
+    RC_DOWN = 0x00000100
+    RC_NEAR = 0x00000000
+  MCW_PC = 0x00030000 # Precision control mask
+    PC_24 = 0x00020000 # 24 bits
+    PC_53 = 0x00010000 # 53 bits
+    PC_64 = 0x00000000 # 64 bits
+end
+
+else
+
+# use ieee_fpu extension
+module IEEE_FPU
+
+  class Error < StandardError
+  end
+
+  def self.get_status
+    status = []
+    if IEEE_FPU_FENV
+      status << fegetround
+      if self.respond_to?(:fegetprec)
+        status << fegetprec
+      elsif IEEE_FPU_CONTROL
+        status << fpu_getprec
+      end
+    else
+      status << fpu_getround
+      status << fpu_getprec
+    end
+    status
+  end
+  def self.set_status(s)
+    r_s,p_s = s
+    if IEEE_FPU_FENV
+      fesetround r_s
+      if self.respond_to?(:fesetprec)
+        fesetprec  p_s
+      elsif IEEE_FPU_CONTROL
+        fpu_setprec  p_s
+      end
+    else
+      fpu_setround r_s
+      fpu_setprec p_s
+    end
+
+  end
+
+  def self.scope(assignments={})
+    v = nil
+    s = get_status
+    prc = assignments[:precision]
+    rnd = assignments[:rounding]
+    self.precision = prc if prc && !(Array===prc)
+    self.rounding =rnd if rnd && !(Array===rnd)
+    if Array===prc
+      param = assignments[:parameters] || [nil]*prc.size
+      v = []
+      i = 0
+      prc.each do |p|
+        self.precision = p
+        v << yield(self, param[i])
+        i += 1
+      end
+    elsif Array===rnd
+      param = assignments[:parameters] || [nil]*rnd.size
+      v = []
+      i = 0
+      rnd.each do |r|
+        self.rounding = r
+        v << yield(self, param[i])
+        i += 1
+      end
+    else
+      v = yield(self)
+    end
+    v
+    ensure
+      set_status s
+  end
+
+  def self.precision
+    p = nil
+    if IEEE_FPU_FENV && self.respond_to?(:fegetprec)
+      v = fegetprec
+      case v
+        when FE_FLTPREC
+          p = :single
+        when FE_DBLPREC
+          p = :double
+        when FE_LDBLPREC
+          p = :extended
+      end
+    elsif IEEE_FPU_CONTROL
+      v = fpu_getprec
+      case v
+        when FPU_SINGLE
+          p = :single
+        when FPU_DOUBLE
+          p = :double
+        when FPU_EXTENDED
+          p = :extended
+      end
+    else
+      p = :double
+    end
+    p
+  end
+  def self.precision=(p)
+    if IEEE_FPU_FENV &&  self.respond_to?(:fesetprec)
+      v = nil
+      case p
+        when :single,24
+          v = FE_FLTPREC
+        when :double,53
+          v = FE_DBLPREC
+        when :extended,64,112
+          v = FE_LDBLPREC
+        else
+          raise Error, "Invalid precision #{p.inspect}"
+      end
+      fesetprec v
+    elsif IEEE_FPU_CONTROL
+      v = nil
+      case p
+        when :single,24
+          v = FPU_SINGLE
+        when :double,53
+          v = FPU_DOUBLE
+        when :extended,64,112
+          v = FPU_EXTENDED
+        else
+          raise Error, "Invalid precision #{p.inspect}"
+      end
+      fpu_setprec v
+    else
+      raise Error, "Precision not supported #{p.inspect}" if p!=:double
+    end
+    p
+  end
+
+  def self.rounding
+    if IEEE_FPU_FENV
+      v = fegetround
+      r = nil
+      case v
+        when FE_UPWARD
+          r = :up
+        when FE_DOWNWARD
+          r = :down
+        when FE_TOWARDZERO
+          r = :zero
+        when FE_TONEAREST
+          r = :even
+      end
+    else
+      v = fpu_getround
+      r = nil
+      case v
+        when FPU_RC_UP
+          r = :up
+        when FPU_RC_DOWN
+          r = :down
+        when FPU_RC_ZERO
+          r = :zero
+        when FPU_RC_NEAREST
+          r = :even
+      end
+    end
+    r
+  end
+
+  def self.rounding=(r)
+    v = nil
+    if IEEE_FPU_FENV
+      case r
+        when :up, :plus_infinity, :positive_infinity
+          v = FE_UPWARD
+        when :down, :minus_inifinity, :negative_infinity
+          v = FE_DOWNWARD
+        when :zero, :truncate, :chop
+          v = FE_TOWARDZERO
+        when :even, :near, :unbiased
+          v = FE_TONEAREST
+        else
+          raise Error, "Invalid rounding mode #{r}"
+        end
+      fesetround v unless v.nil?
+    else
+      case r
+        when :up, :plus_infinity, :positive_infinity
+          v = FPU_RC_UP
+        when :down, :minus_inifinity, :negative_infinity
+          v = FPU_RC_DOWN
+        when :zero, :truncate, :chop
+          v = FPU_RC_ZERO
+        when :even, :near, :unbiased
+          v = FPU_RC_NEAREST
+        else
+          raise Error, "Invalid rounding mode #{r}"
+      end
+      fpu_setround v unless v.nil?
+    end
+    r
+  end
+
+  def self.supported_precisions
+    if (IEEE_FPU_FENV &&  self.respond_to?(:fesetprec)) || IEEE_FPU_CONTROL
+      [:single, :double, :extened]
+    else
+      [:double]
+    end
+  end
+
+end
+
+end

data/test/helper.rb

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'bundler'
+require 'flt'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'ext'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'ieee-fpu'
+
+class Test::Unit::TestCase
+end
+
+
+def test_operation(description, parameters)
+
+  cons = lambda{|x| Float(x)}
+  result = IEEE_FPU.scope(parameters){yield(cons)}
+
+  binnum_parameters = {
+      :rounding => {
+        :even=>:half_even,
+        :down=>:floor,
+        :up=>:ceiling,
+        :zero=>:down
+      }[parameters[:rounding]],
+      :precision => {
+        :single=>24,
+        :double=>53,
+        :extended=>64
+      }[parameters[:rounding]]
+  }
+
+  cons = Flt::BinNum
+  base_context = Flt::BinNum::FloatContext
+  reference = Flt::BinNum.context(base_context, binnum_parameters){yield(cons)}.to_f
+
+  assert_equal reference, result, description
+
+end

data/test/test_ieee-fpu.rb

@@ -0,0 +1,55 @@
+require 'helper'
+
+class TestIeeeFpu < Test::Unit::TestCase
+
+  should "round correctly for each precision supported" do
+
+    IEEE_FPU.supported_precisions.each do |precision|
+      [:up, :down, :zero, :even].each do |rounding|
+        parameters = {
+            :rounding => rounding,
+            :precision => precision
+        }
+
+        test_operation("#{precision} #{rounding} : (2000.0/60)*60/1000 - 2", parameters) do |num|
+          (num[2000]/60)*num[60]/1000 - num[2]
+        end
+
+        test_operation("#{precision} #{rounding} : 1.0+Float::EPSILON/2", parameters) do |num|
+          num[1] + num[Float::EPSILON/2]
+        end
+
+        test_operation("#{precision} #{rounding} : 1.0-Float::EPSILON/4", parameters) do |num|
+          num[1] - num[Float::EPSILON/4]
+        end
+
+        test_operation("#{precision} #{rounding} : -1.0-Float::EPSILON/2", parameters) do |num|
+          num[-1] - num[Float::EPSILON/2]
+        end
+
+        test_operation("#{precision} #{rounding} : -1.0+Float::EPSILON/4", parameters) do |num|
+          num[-1] + num[Float::EPSILON/4]
+        end
+
+        test_operation("#{precision} #{rounding} : 10/9.0-1.0-1/9.0", parameters) do |num|
+          num[10]/num[9]-num[1]-num[1]/num[9]
+        end
+
+        test_operation("#{precision} #{rounding} : -10/9.0+1.0+1/9.0", parameters) do |num|
+          num[-10]/num[9]+num[1]+num[1]/num[9]
+        end
+
+        test_operation("#{precision} #{rounding} : 1-(4.0/3-1)*3", parameters) do |num|
+          num[1] - (num[4]/num[3]-num[1])*num[3]
+        end
+
+        test_operation("#{precision} #{rounding} : (4.0/3-1)*3 - 1", parameters) do |num|
+          (num[4]/num[3]-num[1])*num[3] - num[1]
+        end
+
+      end
+
+    end
+
+  end
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: ieee-fpu
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Javier Goizueta
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+- !ruby/object:Gem::Dependency
+  name: flt
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Control of IEEE compliant FPUs rounding mode and precision
+email: jgoizueta@gmail.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- ext/extconf.rb
+- ext/ieee_fpu_control.c
+- ieee-fpu.gemspec
+- lib/ieee-fpu.rb
+- test/helper.rb
+- test/test_ieee-fpu.rb
+homepage: http://github.com/jgoizueta/ieee-fpu
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3801110420751279703
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Control of IEEE compliant FPUs rounding mode and precision
+test_files: []