crmf 0.1.1

data/ext/crmf/crmf.h

@@ -0,0 +1,29 @@
+#ifndef CRMF_H
+#define CRMF_H
+
+#if defined _WIN32 || defined __CYGWIN__
+  #ifdef BUILDING_DLL
+    #ifdef __GNUC__
+      #define CRMF_PUBLIC __attribute__ ((dllexport))
+    #else
+      #define CRMF_PUBLIC __declspec(dllexport) // Note: actually gcc seems to also supports this syntax.
+    #endif
+  #else
+    #ifdef __GNUC__
+      #define CRMF_PUBLIC __attribute__ ((dllimport))
+    #else
+      #define CRMF_PUBLIC __declspec(dllimport) // Note: actually gcc seems to also supports this syntax.
+    #endif
+  #endif
+  #define CRMF_LOCAL
+#else
+  #if __GNUC__ >= 4
+    #define CRMF_PUBLIC __attribute__ ((visibility ("default")))
+    #define CRMF_LOCAL  __attribute__ ((visibility ("hidden")))
+  #else
+    #define CRMF_PUBLIC
+    #define CRMF_LOCAL
+  #endif
+#endif
+
+#endif /* CRMF_H */

data/ext/crmf/crmf.map

@@ -0,0 +1,7 @@
+CRMF {
+  global:
+    Init_crmf;
+  local:
+    *;
+};
+

data/ext/crmf/extconf.rb

@@ -0,0 +1,68 @@
+require 'mkmf'
+
+dev = not(not(with_config('dev')))
+force_llvm = not(not(with_config('clang-compiler')))
+llvm = ((MakeMakefile::CONFIG['CC'] == 'clang') or force_llvm)
+
+if dev then
+  puts "dev: #{dev}"
+  puts "llvm: #{llvm}"
+end
+
+if force_llvm then
+  MakeMakefile::CONFIG['CC'] =  'clang'
+  MakeMakefile::CONFIG['CXX'] = 'clang++'
+  RbConfig::CONFIG['CC'] =      'clang'
+  RbConfig::CONFIG['CPP'] =     'clang -E'
+  $CFLAGS << ' -fdeclspec -Wno-unknown-warning-option'
+end
+
+unless have_library('gmp') then
+  abort("-----\n#{caller[0]}\nCannot find libgmp\nPleas install GNU MP, e.g. sudo apt install libgmp-dev\n-----")
+end
+
+unless have_library('mpfr') then
+  abort("-----\n#{caller[0]}\nCannot find libmpfr\nPleas install MPFR, e.g. sudo apt install libmpfr-dev\n-----")
+end
+
+ext_dir = File.absolute_path(File.join('..', '..'), __FILE__)
+crlibm_src = File.join(ext_dir, 'crlibm-1.0beta4')
+crlibm_archive = crlibm_src + '.tar.gz'
+crlibm_install_dir = File.join(ext_dir, 'crlibm')
+crlibm_lib_dir = File.join(crlibm_install_dir, 'lib')
+crlibm_inc_dir = File.join(crlibm_install_dir, 'include')
+crlibm_bin_dir = File.join(crlibm_install_dir, 'bin')
+unless File.directory?(crlibm_install_dir) then
+  cmd = "tar xvf '#{crlibm_archive}' -C '#{ext_dir}'"
+  abort "-----\n#{caller[0]}\nCannot untar CRLIBM.\nCommand: \"#{cmd}\"\n-----" unless system(cmd)
+  Dir.chdir(crlibm_src) do
+    cmd = "./configure --prefix='#{crlibm_install_dir}'#{RUBY_PLATFORM =~ /x86_64/ ? ' --enable-sse2 --enable-double-extended' : ''}"
+    abort "-----\n#{caller[0]}\nCannot configure CRLIBM.\nCommand: \"#{cmd}\"\n-----" unless system(cmd)
+    cmd = "make"
+    abort "-----\n#{caller[0]}\nCannot make CRLIBM.\nCommand: \"#{cmd}\"\n-----" unless system(cmd)
+    cmd = "make -j1 install"
+    abort "-----\n#{caller[0]}\nCannot locally install CRLIBM.\nCommand: \"#{cmd}\"\n-----" unless system(cmd)
+  end
+  cmd = "rm -rf '#{crlibm_src}' '#{crlibm_bin_dir}'"
+  abort "-----\n#{caller[0]}\nCannot cleanup CRLIBM.\nCommand: \"#{cmd}\"\n-----" unless system(cmd)
+end
+dir_config('crlibm', crlibm_inc_dir, crlibm_lib_dir)
+abort("-----\n#{caller[0]}\nCannot find libcrlibm in #{crlibm_lib_dir}\n-----") unless have_library('crlibm')
+
+append_cflags  '-fvisibility=hidden'
+append_ldflags '-Wl,--version-script=crmf.map'
+
+if dev then
+  append_cflags '-Wall'
+  append_cflags '-Wextra'
+  append_cflags '-Wno-unused-parameter'
+end
+#append_cflags '-Wno-suggest-attribute=format'
+#append_cflags '-Wno-shift-negative-value'
+#append_cflags '-Wno-sign-compare'
+#append_cflags '-Wno-unused-function'
+
+create_makefile 'crmf/crmf'
+
+File.write('Makefile', File.read('Makefile').sub(/^V = 0$/, 'V = 1').sub(/^all:\s+\$\(DLLIB\)$/, "all:    $(DLLIB)\n\t@cp -vf $< ../../lib/crmf/")) if dev
+

data/lib/crmf/version.rb

@@ -0,0 +1,4 @@
+module CRMF
+  # @return [String] CRMF gem version
+  VERSION = '0.1.1'
+end

data/lib/crmf.rb

@@ -0,0 +1,19 @@
+# Copyright (C) 2022 Théotime Bollengier <theotime.bollengier@ensta-bretagne.fr>
+#
+# This file is part of CRMF. <https://gitlab.ensta-bretagne.fr/bollenth/crmf>
+#
+# CRMF is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published
+# by the Free Software Foundation, either version 3 of the License,
+# or (at your option) any later version.
+#
+# CRMF is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with CRMF. If not, see <https://www.gnu.org/licenses/>. 
+
+require_relative './crmf/crmf'
+require_relative './crmf/version.rb'

data/tests/perf.rb

@@ -0,0 +1,354 @@
+#!/usr/bin/env ruby
+require '../lib/crmf.rb'
+
+def print_time(t)
+  if t >= 3600 then
+    u = 'h'
+    t /= 3600
+  elsif t >= 60 then
+    u = 'm'
+    t /= 60
+  elsif t >= 1 then
+    u = 's '
+  elsif t >= 1e-3 then
+    u = 'ms'
+    t *= 1e3
+  elsif t >= 1e-6 then
+    u = 'µs'
+    t *= 1e6
+  elsif t >= 1e-9 then
+    u = 'ns'
+    t *= 1e9
+  elsif t >= 1e-12 then
+    u = 'ps'
+    t *= 1e12
+  else
+    u = 'fs'
+    t *= 1e15
+  end
+  if t >= 1000 then
+    t = t.round(1)
+  elsif t >= 100 then
+    t = t.round(2)
+  elsif t >= 10 then
+    t = t.round(3)
+  else
+    t = t.round(4)
+  end
+  s = t.to_s
+  bef = s.match(/^(\d+)\./)[1]
+  nbef = bef.length
+  aft = s.match(/.(\d+)$/)[1]
+  naft = aft.length
+  if t >= 1000 then
+    bef = bef.rjust(4)
+  elsif t >= 100 then
+    bef = bef.rjust(3)
+    aft = aft.ljust(2,'0')
+  elsif t >= 10 then
+    bef = bef.rjust(2)
+    aft = aft.ljust(3,'0')
+  else
+    aft = aft.ljust(4,'0')
+  end
+  "#{bef}.#{aft} #{u}"
+end
+
+nb_tests = 100000
+fmin = 0 # -Math::PI/2
+fmax = 1 # Math::PI/2
+famp = fmax - fmin
+f = nb_tests.times.collect{rand()*famp + fmin}
+
+res_libm   = Array.new(nb_tests)
+res_mpfr   = Array.new(nb_tests)
+res_crlibm = Array.new(nb_tests)
+
+funcs = [
+  'sin',
+  'cos',
+  'tan',
+  'asin',
+  'acos',
+  'atan',
+  'sinh',
+  'cosh',
+  'exp',
+  'log',
+  'log2',
+  'log10'
+]
+
+funcs.each do |m|
+  puts " #{m.capitalize} ".center(80, '-')
+
+  mlibm   = Math.method(m.to_sym)
+  mmpfr   = Float.method(m.to_sym)
+  mcrlibm = CRMF.method("#{m}_rn".to_sym)
+
+  tik = Time.now
+  nb_tests.times do |i|
+    res_libm[i] = mlibm.call(f[i])
+  end
+  tok = Time.now
+  t_libm = tok - tik
+  puts "libm:   #{print_time(t_libm)} (#{print_time(t_libm / nb_tests)}/t)"
+
+  tik = Time.now
+  nb_tests.times do |i|
+    res_mpfr[i] = mmpfr.call(f[i])
+  end
+  tok = Time.now
+  t_mpfr = tok - tik
+  puts "mpfr:   #{print_time(t_mpfr)} (#{print_time(t_mpfr / nb_tests)}/t)"
+
+  tik = Time.now
+  nb_tests.times do |i|
+    res_crlibm[i] = mcrlibm.call(f[i])
+  end
+  tok = Time.now
+  t_crlibm = tok - tik
+  puts "crlibm: #{print_time(t_crlibm)} (#{print_time(t_crlibm / nb_tests)}/t)"
+
+  max_diff_pct = 0.0
+  nb_tests.times do |i|
+    next if (not(res_libm[i].finite?) and not(res_mpfr[i].finite?))
+    error_pct = 100.0 * (res_libm[i] - res_mpfr[i]).abs / res_mpfr[i]
+    max_diff_pct = [max_diff_pct, error_pct].max
+  end
+  nb_diff_libm_mpfr = nb_tests.times.count{|i| res_libm[i] != res_mpfr[i]}
+  if nb_diff_libm_mpfr > 0 then
+    estr = ", max error: #{max_diff_pct}%"
+  else
+    estr = ''
+  end
+  puts "libm   vs mpfr: #{nb_diff_libm_mpfr}/#{nb_tests} (#{nb_diff_libm_mpfr*100.0/nb_tests}%)#{estr}"
+  nb_diff_crlibm_mpfr = nb_tests.times.count{|i| res_crlibm[i] != res_mpfr[i]}
+  puts "crlibm vs mpfr: #{nb_diff_crlibm_mpfr}/#{nb_tests} (#{nb_diff_crlibm_mpfr*100.0/nb_tests}%)"
+end
+
+puts
+
+nbtm1 = nb_tests - 1
+
+puts " Add N ".center(80, '-')
+
+tik = Time.now
+nb_tests.times do |i|
+  res_libm[i] = f[i] + f[nbtm1-i] 
+end
+tok = Time.now
+t_libm = tok - tik
+puts "libm:   #{print_time(t_libm)} (#{print_time(t_libm / nb_tests)}/t)"
+
+tik = Time.now
+nb_tests.times do |i|
+  res_mpfr[i] = Float.add(f[i], f[nbtm1-i])
+end
+tok = Time.now
+t_mpfr = tok - tik
+puts "mpfr:   #{print_time(t_mpfr)} (#{print_time(t_mpfr / nb_tests)}/t)"
+
+tik = Time.now
+nb_tests.times do |i|
+  res_crlibm[i] = CRMF.add_rn(f[i], f[nbtm1-i])
+end
+tok = Time.now
+t_crlibm = tok - tik
+puts "crlibm: #{print_time(t_crlibm)} (#{print_time(t_crlibm / nb_tests)}/t)"
+
+max_diff_pct = 0.0
+nb_tests.times do |i|
+  next if (not(res_libm[i].finite?) and not(res_mpfr[i].finite?))
+  error_pct = 100.0 * (res_libm[i] - res_mpfr[i]).abs / res_mpfr[i]
+  max_diff_pct = [max_diff_pct, error_pct].max
+end
+nb_diff_libm_mpfr = nb_tests.times.count{|i| res_libm[i] != res_mpfr[i]}
+if nb_diff_libm_mpfr > 0 then
+  estr = ", max error: #{max_diff_pct}%"
+else
+  estr = ''
+end
+puts "libm   vs mpfr: #{nb_diff_libm_mpfr}/#{nb_tests} (#{nb_diff_libm_mpfr*100.0/nb_tests}%)#{estr}"
+
+max_diff_pct = 0.0
+nb_tests.times do |i|
+  next if (not(res_crlibm[i].finite?) and not(res_mpfr[i].finite?))
+  error_pct = 100.0 * (res_crlibm[i] - res_mpfr[i]).abs / res_mpfr[i]
+  max_diff_pct = [max_diff_pct, error_pct].max
+end
+nb_diff_crlibm_mpfr = nb_tests.times.count{|i| res_crlibm[i] != res_mpfr[i]}
+if nb_diff_crlibm_mpfr > 0 then
+  estr = ", max error: #{max_diff_pct}%"
+else
+  estr = ''
+end
+puts "crlibm vs mpfr: #{nb_diff_crlibm_mpfr}/#{nb_tests} (#{nb_diff_crlibm_mpfr*100.0/nb_tests}%)#{estr}"
+
+
+puts " Add D ".center(80, '-')
+
+tik = Time.now
+nb_tests.times do |i|
+  res_libm[i] = f[i] + f[nbtm1-i] 
+end
+tok = Time.now
+t_libm = tok - tik
+puts "libm:   #{print_time(t_libm)} (#{print_time(t_libm / nb_tests)}/t)"
+
+tik = Time.now
+nb_tests.times do |i|
+  res_mpfr[i] = Float.add(f[i], f[nbtm1-i], :down)
+end
+tok = Time.now
+t_mpfr = tok - tik
+puts "mpfr:   #{print_time(t_mpfr)} (#{print_time(t_mpfr / nb_tests)}/t)"
+
+tik = Time.now
+nb_tests.times do |i|
+  res_crlibm[i] = CRMF.add_rd(f[i], f[nbtm1-i])
+end
+tok = Time.now
+t_crlibm = tok - tik
+puts "crlibm: #{print_time(t_crlibm)} (#{print_time(t_crlibm / nb_tests)}/t)"
+
+max_diff_pct = 0.0
+nb_tests.times do |i|
+  next if (not(res_libm[i].finite?) and not(res_mpfr[i].finite?))
+  error_pct = 100.0 * (res_libm[i] - res_mpfr[i]).abs / res_mpfr[i]
+  max_diff_pct = [max_diff_pct, error_pct].max
+end
+nb_diff_libm_mpfr = nb_tests.times.count{|i| res_libm[i] != res_mpfr[i]}
+if nb_diff_libm_mpfr > 0 then
+  estr = ", max error: #{max_diff_pct}%"
+else
+  estr = ''
+end
+puts "libm   vs mpfr: #{nb_diff_libm_mpfr}/#{nb_tests} (#{nb_diff_libm_mpfr*100.0/nb_tests}%)#{estr}"
+
+max_diff_pct = 0.0
+nb_tests.times do |i|
+  next if (not(res_crlibm[i].finite?) and not(res_mpfr[i].finite?))
+  error_pct = 100.0 * (res_crlibm[i] - res_mpfr[i]).abs / res_mpfr[i]
+  max_diff_pct = [max_diff_pct, error_pct].max
+end
+nb_diff_crlibm_mpfr = nb_tests.times.count{|i| res_crlibm[i] != res_mpfr[i]}
+if nb_diff_crlibm_mpfr > 0 then
+  estr = ", max error: #{max_diff_pct}%"
+else
+  estr = ''
+end
+puts "crlibm vs mpfr: #{nb_diff_crlibm_mpfr}/#{nb_tests} (#{nb_diff_crlibm_mpfr*100.0/nb_tests}%)#{estr}"
+
+
+
+puts " Add U ".center(80, '-')
+
+tik = Time.now
+nb_tests.times do |i|
+  res_libm[i] = f[i] + f[nbtm1-i] 
+end
+tok = Time.now
+t_libm = tok - tik
+puts "libm:   #{print_time(t_libm)} (#{print_time(t_libm / nb_tests)}/t)"
+
+tik = Time.now
+nb_tests.times do |i|
+  res_mpfr[i] = Float.add(f[i], f[nbtm1-i], :up)
+end
+tok = Time.now
+t_mpfr = tok - tik
+puts "mpfr:   #{print_time(t_mpfr)} (#{print_time(t_mpfr / nb_tests)}/t)"
+
+tik = Time.now
+nb_tests.times do |i|
+  res_crlibm[i] = CRMF.add_ru(f[i], f[nbtm1-i])
+end
+tok = Time.now
+t_crlibm = tok - tik
+puts "crlibm: #{print_time(t_crlibm)} (#{print_time(t_crlibm / nb_tests)}/t)"
+
+max_diff_pct = 0.0
+nb_tests.times do |i|
+  next if (not(res_libm[i].finite?) and not(res_mpfr[i].finite?))
+  error_pct = 100.0 * (res_libm[i] - res_mpfr[i]).abs / res_mpfr[i]
+  max_diff_pct = [max_diff_pct, error_pct].max
+end
+nb_diff_libm_mpfr = nb_tests.times.count{|i| res_libm[i] != res_mpfr[i]}
+if nb_diff_libm_mpfr > 0 then
+  estr = ", max error: #{max_diff_pct}%"
+else
+  estr = ''
+end
+puts "libm   vs mpfr: #{nb_diff_libm_mpfr}/#{nb_tests} (#{nb_diff_libm_mpfr*100.0/nb_tests}%)#{estr}"
+
+max_diff_pct = 0.0
+nb_tests.times do |i|
+  next if (not(res_crlibm[i].finite?) and not(res_mpfr[i].finite?))
+  error_pct = 100.0 * (res_crlibm[i] - res_mpfr[i]).abs / res_mpfr[i]
+  max_diff_pct = [max_diff_pct, error_pct].max
+end
+nb_diff_crlibm_mpfr = nb_tests.times.count{|i| res_crlibm[i] != res_mpfr[i]}
+if nb_diff_crlibm_mpfr > 0 then
+  estr = ", max error: #{max_diff_pct}%"
+else
+  estr = ''
+end
+puts "crlibm vs mpfr: #{nb_diff_crlibm_mpfr}/#{nb_tests} (#{nb_diff_crlibm_mpfr*100.0/nb_tests}%)#{estr}"
+
+
+puts " Add Z ".center(80, '-')
+
+tik = Time.now
+nb_tests.times do |i|
+  res_libm[i] = f[i] + f[nbtm1-i] 
+end
+tok = Time.now
+t_libm = tok - tik
+puts "libm:   #{print_time(t_libm)} (#{print_time(t_libm / nb_tests)}/t)"
+
+tik = Time.now
+nb_tests.times do |i|
+  res_mpfr[i] = Float.add(f[i], f[nbtm1-i], :zero)
+end
+tok = Time.now
+t_mpfr = tok - tik
+puts "mpfr:   #{print_time(t_mpfr)} (#{print_time(t_mpfr / nb_tests)}/t)"
+
+tik = Time.now
+nb_tests.times do |i|
+  res_crlibm[i] = CRMF.add_rz(f[i], f[nbtm1-i])
+end
+tok = Time.now
+t_crlibm = tok - tik
+puts "crlibm: #{print_time(t_crlibm)} (#{print_time(t_crlibm / nb_tests)}/t)"
+
+max_diff_pct = 0.0
+nb_tests.times do |i|
+  next if (not(res_libm[i].finite?) and not(res_mpfr[i].finite?))
+  error_pct = 100.0 * (res_libm[i] - res_mpfr[i]).abs / res_mpfr[i]
+  max_diff_pct = [max_diff_pct, error_pct].max
+end
+nb_diff_libm_mpfr = nb_tests.times.count{|i| res_libm[i] != res_mpfr[i]}
+if nb_diff_libm_mpfr > 0 then
+  estr = ", max error: #{max_diff_pct}%"
+else
+  estr = ''
+end
+puts "libm   vs mpfr: #{nb_diff_libm_mpfr}/#{nb_tests} (#{nb_diff_libm_mpfr*100.0/nb_tests}%)#{estr}"
+
+max_diff_pct = 0.0
+nb_tests.times do |i|
+  next if (not(res_crlibm[i].finite?) and not(res_mpfr[i].finite?))
+  error_pct = 100.0 * (res_crlibm[i] - res_mpfr[i]).abs / res_mpfr[i]
+  max_diff_pct = [max_diff_pct, error_pct].max
+end
+nb_diff_crlibm_mpfr = nb_tests.times.count{|i| res_crlibm[i] != res_mpfr[i]}
+if nb_diff_crlibm_mpfr > 0 then
+  estr = ", max error: #{max_diff_pct}%"
+else
+  estr = ''
+end
+puts "crlibm vs mpfr: #{nb_diff_crlibm_mpfr}/#{nb_tests} (#{nb_diff_crlibm_mpfr*100.0/nb_tests}%)#{estr}"
+
+

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: crmf
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Théotime Bollengier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-07-21 00:00:00.000000000 Z
+dependencies: []
+description: CRMF is a Ruby C extension which provides correctly rounded math functions
+  for Ruby floats, using MPFR and CRlibm. Provided rounding modes are toward zero,
+  +infinity, -infinity a to nearest even.
+email: theotime.bollengier@ensta-bretagne.fr
+executables: []
+extensions:
+- ext/crmf/extconf.rb
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- LICENSE
+- README.md
+- crmf.gemspec
+- ext/crlibm-1.0beta4.tar.gz
+- ext/crmf/crmf.c
+- ext/crmf/crmf.h
+- ext/crmf/crmf.map
+- ext/crmf/extconf.rb
+- lib/crmf.rb
+- lib/crmf/version.rb
+- tests/perf.rb
+homepage: https://gitlab.ensta-bretagne.fr/bollenth/crmf
+licenses:
+- GPL-3.0+
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key: 
+specification_version: 4
+summary: Correctly rounded math functions for Ruby floats
+test_files: []