crmf 0.1.1 → 0.1.3

data/ext/crlibm-1.0beta5/scs_lib/division_scs.c

@@ -0,0 +1,110 @@
+/** Functions for SCS inverse and division
+
+@file division_scs.c
+
+@author Defour David David.Defour@ens-lyon.fr
+@author Florent de Dinechin Florent.de.Dinechin@ens-lyon.fr 
+ 
+This file is part of the SCS library.
+
+
+*/
+
+/*
+Copyright (C) 2002  David Defour and Florent de Dinechin
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+ */
+#include "scs.h"
+#include "scs_private.h"
+
+
+void scs_div_2(scs_ptr num) {
+  /* small function to divide by 2 any SCS number */
+  unsigned int carry, mask, old_value;
+  int i;
+  carry = 0x00000000;
+  mask = (unsigned int)(((0x1) << SCS_NB_BITS)-1);/*we now have a mask for the used bits in a word*/
+  /* if it's a normal number, i.e. not zero nor NaN */
+  if( (num->exception).d == (double) 1) {
+    /* first, a loop to rotate all numbers to the right*/
+    for(i = 0; i < SCS_NB_WORDS; i++) {
+      old_value = num->h_word[i];
+      num->h_word[i] = (old_value & !mask) | carry | ((old_value >> 1) & mask);
+      carry = old_value & 0x00000001;/* it can be interesting to keep the last bit of each number =) */
+      carry = carry << (SCS_NB_BITS-1);
+    }
+    /* In the SCS format, the first number can't be zero, so we must handle this particular case */
+    if (num->h_word[0] == 0){
+      num->index = num->index - 1;
+      for(i = 1; i < SCS_NB_WORDS; i++) {
+	num->h_word[i-1] = num->h_word[i];
+      }
+      num->h_word[SCS_NB_WORDS-1] = 0;
+    }
+  }
+  else {
+    (num->exception).d = (num->exception).d / 2;/* zero, NaN, ... */
+  }
+}
+
+
+
+
+/*
+ * Compute 1/x with a Newton scheme
+ */
+void scs_inv(scs_ptr result, scs_ptr x){
+  scs_t tmp, res, res1, scstwo;
+  double app_x, inv;
+  
+  scs_set(tmp, x);  tmp->index = 0;  scs_get_d(&app_x, tmp);
+
+  scs_set_si(scstwo, 2);
+  /* inv is a 53-bit approximation of 1/x */
+  inv = 1/app_x;
+  
+  scs_set_d(res, inv);
+  res->index -= x->index;
+
+  /* First Newton Iteration */
+  scs_mul(res1, x, res);
+  scs_sub(res1, scstwo, res1);
+  scs_mul(res, res, res1);
+
+  /* Second Newton Iteration */
+  scs_mul(res1, x, res);
+  scs_sub(res1, scstwo, res1);
+  scs_mul(result, res, res1); 
+
+  return;
+}
+
+/*
+ * Compute result = x/y; 
+ */
+void scs_div(scs_ptr result, scs_ptr x, scs_ptr y){ 
+  scs_t res;
+ 
+  if (X_EXP != 1){
+    R_EXP = X_EXP / Y_EXP;
+    return;
+  }
+
+  scs_inv(res, y);
+  scs_mul(result, res, x);
+  return;
+}

data/ext/crlibm-1.0beta5/scs_lib/double2scs.c

@@ -0,0 +1,174 @@
+/** Conversion of floating-point double to SCS
+@file double2scs.c
+
+@author Defour David David.Defour@ens-lyon.fr
+@author Florent de Dinechin Florent.de.Dinechin@ens-lyon.fr 
+
+This file is part of the SCS library.
+*/
+
+/*
+Copyright (C) 2002  David Defour and Florent de Dinechin
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+ */
+#include "scs.h"
+#include "scs_private.h"
+
+
+/** Convert a double precision number in it SCS multiprecision
+  representation
+ */
+
+void scs_set_d(scs_ptr result, double x){
+  db_number nb, mantissa;
+  int exponent, exponent_remainder;
+  int ind, i;
+
+  if(x>=0){R_SGN = 1;    nb.d = x;}
+  else    {R_SGN = -1;   nb.d = -x;}
+
+  exponent = nb.i[HI] & 0x7ff00000 ;
+
+  if (exponent == 0x7ff00000)  {
+    /*
+     * x = +/- Inf, s/qNAN
+     */
+    R_EXP = x;  
+    for(i=0; i<SCS_NB_WORDS; i++)
+      R_HW[i] = 0;
+ 
+    R_IND = 0;
+    R_SGN = 1;
+  } 
+
+  else {    /* Normals,  denormals, +/- 0.  */
+
+    /* This number is not an exception */
+    R_EXP = 1;
+
+#if 1
+
+    if (exponent == 0){
+      /* x is a denormal number : bring it back to the normal range */
+      nb.d = nb.d * SCS_RADIX_TWO_DOUBLE;      /* 2^(2.SCS_NB_BITS) */
+      exponent = nb.i[HI] & 0x7ff00000 ;
+      R_IND = -2;
+    }else {
+      R_IND = 0;
+    }
+
+    exponent = exponent >> 20;  /* get the actual value */
+
+    ind = ((exponent +((100*SCS_NB_BITS)-1023))/SCS_NB_BITS) - 100 ;  
+    /* means : = (exponent -1023 + 100*SCS_NB_BITS)/SCS_NB_BITS -100 
+     The business with 100*SCS_NB_BITS is to stay within the positive
+     range for exponent_remainder between 1 and SCS_NB_BITS */
+
+    exponent_remainder = exponent - 1022 - (SCS_NB_BITS*ind);
+
+    R_IND += ind;
+
+    /* now get the mantissa and add the implicit 1 in fp. format*/
+    mantissa.l = (nb.l & ULL(000fffffffffffff)) | ULL(0010000000000000);
+
+
+    /* and spread it over the structure
+       Everything here is 64-bit arithmetic */
+    R_HW[0] = (unsigned int) (mantissa.l >> (53 - exponent_remainder) );
+
+    /* 11 = 64-53 */
+    mantissa.l =  (mantissa.l << (exponent_remainder+11));
+    R_HW[1] = (mantissa.i[HI] >> (32 - SCS_NB_BITS))& SCS_MASK_RADIX ;
+    mantissa.l =  (mantissa.l << SCS_NB_BITS);
+    R_HW[2] = (mantissa.i[HI] >> (32 - SCS_NB_BITS))& SCS_MASK_RADIX ;
+#if SCS_NB_BITS < 27
+    mantissa.l =  (mantissa.l << SCS_NB_BITS);
+    R_HW[3] = (mantissa.i[HI] >> (32 - SCS_NB_BITS))& SCS_MASK_RADIX ;
+#else
+    R_HW[3] = 0 ;
+#endif
+
+#if (SCS_NB_WORDS==8)
+      R_HW[4] = 0; R_HW[5] = 0; R_HW[6] = 0; R_HW[7] = 0;
+#else
+    for(i=4; i<SCS_NB_WORDS; i++)
+      R_HW[i] = 0;
+#endif
+
+
+
+#else /* Other algorithm as in the research report. Slower */
+    R_IND = 0;
+
+    while(nb.d>SCS_RADIX_ONE_DOUBLE) {
+	R_IND++;
+	nb.d *= SCS_RADIX_MONE_DOUBLE;
+      }
+
+    while(nb.d<1)  {
+	R_IND--;
+	nb.d *= SCS_RADIX_ONE_DOUBLE;
+      }
+
+    i=0;
+    while(nb.d != 0){
+      R_HW[i] = (unsigned int) nb.d;
+      nb.d = (nb.d - (double)R_HW[i]) * SCS_RADIX_ONE_DOUBLE;
+      i++;
+    }
+    for(; i<SCS_NB_WORDS; i++)
+      R_HW[i] = 0;
+
+#endif
+
+  } /* end if test NaN etc */
+
+  return;
+}
+
+
+/**
+  Convert an integer number in it scs multiprecision
+  representation
+ */
+void scs_set_si(scs_ptr result, int x){
+  unsigned int ux;
+  int i;
+  
+  if(x>=0){R_SGN = 1;   ux = (unsigned int)x;}
+  else    {R_SGN = -1;  ux = (unsigned int)-x;}
+  
+
+  if (ux > SCS_RADIX){
+    R_IND   = 1;
+    R_HW[0] = (ux - SCS_RADIX) >> SCS_NB_BITS;
+    R_HW[1] =  ux - (R_HW[0] << SCS_NB_BITS);
+  }else {
+    R_IND   = 0;
+    R_HW[0] = ux;
+    R_HW[1] = 0;
+  }
+
+  for(i=2; i<SCS_NB_WORDS; i++)
+    R_HW[i] = 0;
+
+  if (x != 0)  R_EXP = 1;
+  else         R_EXP = 0;
+  
+  return;
+}
+

data/ext/crlibm-1.0beta5/scs_lib/main.dox

@@ -0,0 +1,104 @@
+/* What goes on the main page of SCSLib as generated by doxygen. */
+
+/**@mainpage SCSLib, the Software Carry-Save multiple-precision library
+
+
+   @section intro Introduction
+
+SCSLib is a fast and lightweight multiple-precision library developped
+in the Arénaire project at ENS Lyon. It was developed as a building
+block for evaluating elementary functions with correct rounding. Its
+interesting features are:
+
+- Compile-time selected precision: SCSLib is a fixed-precision
+library, where precision is selected at compile-time for
+performance. Out-of-the-box, the library ensures 210 bits of precision
+(quad-double). It is easily configurable to do any precision between
+twice or half that, and with a little bit more work it can in
+principle ensure up to a few thousand bits.
+
+- Floating-point format: The SCS format is a floating-point format
+where exponents are machine integers (usually 32-bit numbers), which
+ensures a huge exponent range.  
+
+- Supported operations: SCSLib currently offers addition/subtraction,
+multiplication, and an experimental division, plus all the useful 
+conversion functions.  
+
+- IEEE-754 compatibility: The range of SCS numbers include the range
+of IEEE double-precision numbers, including denormals and exceptional
+cases. Conversions between SCS format and IEEE-754 doubles, as well as
+arithmetic operations, follow the IEEE rules concerning the
+exceptional cases. SCS doesn't ensure correct rounding, but provides
+conversions to doubles in the four IEEE-754 rounding modes.
+
+- Performance: SCSLib is designed to be fast. With 210 bits, it
+  outperforms MPF for most operations on most architectures.
+
+- Licence: This library is distributed under the LGPL. See inside the
+  archive for details.
+
+
+SCSLib is still under development and hasn't been tested on all
+possible combinations of architecture and environment. If you think
+you have found a bug, please investigate and report it.
+
+All you need to build SCSLib is a C compiler compliant with the ANSI
+C99 standard. So far we have successfully tested the following compilers:
+- gcc-2.95x 
+- gcc-3.0x 
+ 
+
+
+
+  @section install Installation
+
+Standard installation should only require
+- ./configure 
+- make
+
+Compile-time options may be passed to configure 
+- to change the precision (default is 200 bits)
+- to link with the GNU multiple-precision package MPFR 
+   (for testing and debugging purpose)
+
+See the INSTALL file and configure --help for details
+
+
+
+
+  @section using Linking with the SCS library  
+
+To use SCSLib you need to include the header file
+ scs.h. See the documentation of this file for details. Then you need
+to link with libscs.a.
+
+For C++ users we provide a wrapper class wrapper_scs.h that
+overloads the basic arithmetic operators with SCS operations. It
+hasn't been tested extensively.
+   
+
+
+   @section bugs Reporting bugs
+
+Please report bugs at the following address: scslib@ens-lyon.fr
+
+
+   @section copyleft Copyright and license
+
+Copyright (C) 2002  Catherine Daramy, David Defour and Florent de Dinechin
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/