intervals 0.3.56

data/ext/crlibm/scs_lib/poly_fct.c

@@ -0,0 +1,112 @@
+/*
+ * Author  : Defour David
+ * Contact : David.Defour@ens-lyon.fr
+ *
+ * This program 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 of the License, or 
+ * (at your option) any later version.
+ * 
+ * This program 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 Lesser General Public License
+ * along with this program; 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"
+
+
+/*
+ * result = z + (x * y)
+ */
+/* z->sign = X_SGN . Y_SGN */
+void scs_fma(scs_ptr result,  scs_ptr x,  scs_ptr y,  scs_ptr z){
+  uint64_t RES[2*SCS_NB_WORDS];
+  uint64_t val, tmp;
+  int i, j, ind, Diff;    
+
+  ind = X_IND + Y_IND; 
+
+  for(i=0; i<=SCS_NB_WORDS+1; i++)
+    RES[i]=0;
+  
+  for(i=0 ; i<SCS_NB_WORDS; i++){
+    for(j=0; j<(SCS_NB_WORDS-i); j++){
+      RES[i+j] += (uint64_t)X_HW[i] * Y_HW[j];
+    }}
+
+  /* if we can perform an add */
+  if (z->sign == (X_SGN * Y_SGN)){
+    Diff = z->index - ind;
+    if (Diff >= 0){
+      for(i=(SCS_NB_WORDS-1), j=(SCS_NB_WORDS-Diff); j>=0; i--, j--)
+	RES[i] = z->h_word[i] + RES[j];     
+      for(  ; i>=0; i--)
+	RES[i] = z->h_word[i]; 
+    }else {    
+      for(i=(SCS_NB_WORDS+Diff), j=(SCS_NB_WORDS-1); i>=0; i--, j--)
+	RES[j] = z->h_word[i] + RES[j];     
+    }
+
+    /* Carry propagate */
+    RES[SCS_NB_WORDS-1] += (RES[SCS_NB_WORDS]>>SCS_NB_BITS);
+    for(i=(SCS_NB_WORDS-1); i>0; i--)
+      {tmp = RES[i]>>SCS_NB_BITS;  RES[i-1] += tmp;  RES[i] -= (tmp<<SCS_NB_BITS);}
+    
+    val = RES[0] >> SCS_NB_BITS;
+    R_IND = X_IND + Y_IND;
+    
+    /* Store the result */
+    if(val != 0){
+      /* shift all the digits ! */     
+      R_HW[0] = (unsigned int)val;
+      R_HW[1] = (unsigned int)(RES[0] - (val<<SCS_NB_BITS));
+      for(i=2; i<SCS_NB_WORDS; i++)
+	R_HW[i] = (unsigned int)RES[i-1];
+      
+      R_IND += 1;
+    }
+    else {
+      for(i=0; i<SCS_NB_WORDS; i++)
+	R_HW[i] = (unsigned int)RES[i];
+    }
+    
+    R_EXP = (z->exception.d + (X_EXP * Y_EXP)) - 1;
+    R_SGN = X_SGN * Y_SGN;
+  
+  }else {
+    /* we have to do a sub */
+
+    /* Carry propagate */
+    RES[SCS_NB_WORDS-1] += (RES[SCS_NB_WORDS]>>SCS_NB_BITS);
+    for(i=(SCS_NB_WORDS-1); i>0; i--)
+      {tmp = RES[i]>>SCS_NB_BITS;  RES[i-1] += tmp;  RES[i] -= (tmp<<SCS_NB_BITS);}
+    
+    val = RES[0] >> SCS_NB_BITS;
+    R_IND = X_IND + Y_IND;
+    
+    /* Store the result */
+    if(val != 0){
+      /* shift all the digits ! */     
+      R_HW[0] = (unsigned int)val;
+      R_HW[1] = (unsigned int)(RES[0] - (val<<SCS_NB_BITS));
+      for(i=2; i<SCS_NB_WORDS; i++)
+	R_HW[i] = (unsigned int)RES[i-1];
+      
+      R_IND += 1;
+    }
+    else {
+      for(i=0; i<SCS_NB_WORDS; i++)
+	R_HW[i] = (unsigned int)RES[i];
+    }
+    
+    R_EXP = (X_EXP * Y_EXP);
+    R_SGN = X_SGN * Y_SGN;
+
+    scs_add(result, result, z);
+  }
+}

data/ext/crlibm/scs_lib/print_scs.c

@@ -0,0 +1,73 @@
+/*
+ * Author  : Defour David
+ * Contact : David.Defour@ens-lyon.fr
+ *
+ * This program 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 of the License, or 
+ * (at your option) any later version.
+ * 
+ * This program 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 Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+ */
+#include <stdio.h>
+#include "scs.h"
+#include "scs_private.h"
+
+
+/*
+ * used by the next function to write
+ * bit of the integer in the right order ....
+ */
+static void print_order(unsigned int x, int nb, int b){
+  if (nb<=0)
+    return;
+  print_order(x/b, nb-1, b);
+  printf("%u",x%b);
+  return;
+}
+/*
+ * print nb digits of the chain x in base "b"
+ * b must be between 1 and 10
+ */ 
+static void print_integer(unsigned int x, int b, int nb){
+   
+  if ((b < 2)||(b>16)){
+    fprintf(stderr," ERROR: You musn't print number with a base larger than 10 or less than 2 \n");
+    return;
+  }
+  print_order(x, nb, b);
+  return;
+}
+
+
+/*
+ * Convert a double precision number in it scs multiprecision
+ * representation
+ *
+ * Rem. : We haven't tested all special cases yet.
+ */
+
+/*
+ */
+void scs_get_std( scs_ptr x){
+  int i; 
+  db_number d;
+
+  scs_get_d(&d.d, x);
+  printf("Exception : %e \n", X_EXP);
+  printf("Index= %d   \n Sign=  %d \n Double value= %.30e   \n Hex mantissa= %x %x\n", 
+	 X_IND, X_SGN, d.d, d.i[HI], d.i[LO]);
+  for(i=0;i<SCS_NB_WORDS;i++){
+    printf("  D %d :  %8x %20u \n",i, X_HW[i], X_HW[i]);
+  }
+}
+
+
+

data/ext/crlibm/scs_lib/rand_scs.c

@@ -0,0 +1,63 @@
+/*
+ * Author  : Defour David
+ * Contact : David.Defour@ens-lyon.fr
+ *
+ * This program 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 of the License, or 
+ * (at your option) any later version.
+ * 
+ * This program 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 Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  
+ */
+#include <stdlib.h>
+#include "scs.h"
+#include "scs_private.h"
+
+/*
+ * Return 'sizeof(int)' random bits   
+ */
+
+
+int rand_val(void){
+  int val;
+  int i;
+
+  val = (rand() & 0x000000ff);
+  for(i=0; i<(sizeof(int)); i++){
+    val = val << 8;
+    val += (rand() & 0x000000ff ); /* we keep only 8 bits */
+  }
+  return val;
+}
+
+
+/*
+ * Put into 'result' a scs random number with the index field set
+ * with a value between -expo_max and +expo_max.
+ *
+ * Rem. :
+ * 1) If you want an scs number belonging to double precision floating
+ * point number you must call scs_rand with an expo_max less than 39.
+ * 2) expo_max must be less than RAND_MAX that is usually set a
+ * value greater than 32767
+ */
+void scs_rand(scs_ptr result, int expo_max){
+  int i;
+
+  R_EXP = 1;
+  R_IND = (rand() % (2*expo_max)) - expo_max;
+  R_SGN = ((2*rand()- RAND_MAX) > 0) ?  (-1) : (1);
+
+  
+  for(i=0; i<SCS_NB_WORDS; i++){
+    /* We keep the first SCS_NB_BITS bits of a random value */
+    R_HW[i] = rand_val() & SCS_MASK_RADIX; 
+  }
+}

data/ext/crlibm/scs_lib/scs.h

@@ -0,0 +1,353 @@
+/** This is the main header file of the SCS library, which defines the
+    SCS data structure, and the functions that implement arithmetic on it.
+
+@file scs.h
+
+@author David Defour 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
+
+*/
+
+
+
+/* Avoid loading the header twice */
+#ifndef INCLUDE_SCS 
+#define INCLUDE_SCS 1
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS /* because it is not very clean */
+
+#ifdef HAVE_CONFIG_H
+#include "../crlibm_config.h"
+#endif
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+
+
+
+/* 64 bit arithmetic may be standardised, but people still do want they want */
+#ifdef HAVE_INTTYPES_H
+#define ULL(bits) 0x##bits##uLL
+#elif defined(WIN32) 
+/* TODO insert Windows garbage there */
+/* Default, hoping it works, hopefully less and less relevant */
+#else
+typedef long long int64_t;
+typedef unsigned long long uint64_t; 
+#define ULL(bits) 0x##bits##uLL
+#endif
+
+#ifndef SCS_DEF_INT64 
+#define SCS_DEF_INT64
+#ifdef SCS_TYPEOS_HPUX
+#ifndef __LP64__ /* To solve the problem with 64 bits integer */
+typedef long long int64_t;
+typedef unsigned long long uint64_t;
+#define ULL(bits) 0x##bits##uLL
+#endif
+#endif
+#endif
+
+
+#ifdef HAVE_GMP_H
+ #include <gmp.h>
+#endif
+
+#ifdef HAVE_MPFR_H
+ #include <mpfr.h>
+#endif
+
+
+#endif /* DOXYGEN_SHOULD_SKIP_THIS */
+
+
+/** @internal An union to cast floats into doubles or the other way round. For
+    internal purpose only */
+
+typedef union {
+  int32_t i[2]; /* Signed (may be useful) */                
+  int64_t l;    /* Signed (may be useful) */
+  double d;
+} db_number;
+
+
+
+
+
+/* ****************************************************************** */
+/**@name SCS data-types */ /**@{*/
+
+/** @struct scs 
+The SCS data type. 
+
+An SCS number is a a floating-point number in base 2^32.
+
+- Its mantissa is formed of SCS_NB_WORDS digits (currently 32 bits by default)
+
+- Its exponent is a 32-bit integer
+
+- It also has a sign field, and an exception field used to store and
+  propagate IEEE-754 exceptions.
+
+
+The real number represented by a scs structure is equal to:
+@f$
+\displaystyle 
+\sum_{i=0}^{\mathtt{SCS\_NB\_WORDS}} 
+2^{(\mathtt{index} -i)\mathtt{SCS\_NB\_BITS}}
+\times
+\mathtt{h\_word}[i] 
+@f$
+*/
+
+/*
+  (verbatim-mode formula for the above eqation:) the number represented by a
+  SCS structure is :
+
+         i<SCS_NB_WORDS               (index - i).SCS_NB_BITS
+ sign . (    sum       ( h_word[i] . 2^                        ) 
+            i=0 
+*/
+
+struct scs {
+  /** the digits, as 32 bits words */ 
+  uint32_t h_word[SCS_NB_WORDS]; 
+  /** Used to store Nan,+/-0, Inf, etc and then let the hardware handle them */
+  db_number exception;   
+  /** This corresponds to the exponent in an FP format, but here we are
+     in base 2^32  */
+  int index;        
+  /** The sign equals 1 or -1*/
+  int sign;              
+};
+
+
+typedef struct scs scs;
+
+
+
+/** scs_ptr is a pointer on a SCS structure */
+typedef struct scs * scs_ptr;
+
+
+
+
+/** scs_t is an array of one SCS struct to lighten syntax : you may
+ declare a scs_t object, and pass it to the scs functions (which
+ expect pointers) without using ampersands.
+*/
+typedef struct scs scs_t[1];
+
+/**@}*/ /* end doxygen group for SCS data-types */
+
+
+
+
+
+
+
+
+/* ****************************************************************** */
+/**@name Conversion and initialization functions  */ /**@{*/
+
+/** Convert a SCS number to a double, rounding to the nearest */
+void scs_get_d(double*, scs_ptr);
+
+/** Convert a SCS number to a double, rounding towards minus infinity */
+void scs_get_d_minf(double*, scs_ptr);
+
+/** Convert a SCS number to a double, rounding towards plus infinity */
+void scs_get_d_pinf(double*, scs_ptr);
+
+/** Convert a SCS number to a double, rounding towards zero */
+void scs_get_d_zero(double*, scs_ptr);
+
+/** Convert a double into a SCS number (this is an exact operation) */
+void scs_set_d(scs_ptr, double);
+
+/** Convert a signed int into a SCS number (this is an exact operation) */
+void scs_set_si(scs_ptr, signed int);
+
+
+/** Print out a SCS number. Sorry for the strange name, we are mimicking GMP */
+void scs_get_std(scs_ptr);
+
+
+/** Copy a SCS number into another */
+void scs_set(scs_ptr, scs_ptr); 
+
+
+/** Set a SCS number to zero */
+void scs_zero(scs_ptr);
+
+
+/** Generate a random SCS number. 
+   The index field of result will be between -expo_max and +expo_max.
+   Example: to get a number in the double-precision floating-point range,
+   expo_max should be smaller than 39.
+   @warning No guarantee is made about the quality of the random algorithm
+   used... */
+void scs_rand(scs_ptr result, int expo_max);
+
+/**@}*/ /* end doxygen group for conversion / initialisation functions*/
+
+
+
+
+/* ****************************************************************** */
+/**@name Addition and renormalisation functions  */ /**@{*/
+
+
+/** Addition of two SCS numbers.  
+ The arguments x, y and result may point to the same memory
+ location. The result is a normalised SCS number.
+*/
+void scs_add(scs_ptr result, scs_ptr x, scs_ptr y);
+
+
+/** Subtraction of two SCS numbers.  
+ The arguments x, y and result may point to the same memory
+ location. The result is a normalised SCS number.
+ */
+void scs_sub(scs_ptr result, scs_ptr x, scs_ptr y);
+
+
+/** Addition without renormalisation, to be used for adding many
+   numbers.
+  @warning  In case of a cancellation, severe loss of precision could
+   happen. Safe if the numbers are of the same sign.
+ */
+void scs_add_no_renorm(scs_ptr result, scs_ptr x, scs_ptr y);
+
+
+/** Renormalisation (to be used after several scs_add_no_renorm).
+This function removes the carry from each digit, and also shifts the
+digits in case of a cancellation (so that if result != 0 then its
+first digit is non-zero)
+ 
+ @warning THIS FUNCTION HAS NEVER BEEN PROPERLY TESTED and is
+ currently unused in the library: instead, specific renormalisation
+ steps are fused within the code of the operations which require it.
+  */
+
+void scs_renorm(scs_ptr);
+
+
+/** Renormalisation assuming no cancellation.  This function is useful
+   for example when adding many numbers of the same sign */
+void scs_renorm_no_cancel_check(scs_ptr);
+
+/**@}*/ /* end doxygen group for addition and normalisation functions*/
+
+
+
+
+/* ****************************************************************** */
+/**@name Multiplication functions */ /**@{*/
+
+/** Multiplication of two SCS numbers.  The arguments x, y and result
+ may point to the same memory location. The result is a normalised SCS
+ number.
+ */
+void scs_mul(scs_ptr result, const scs_ptr x, const scs_ptr y);
+
+/** Multiplication of a SCS with an unsigned integer; result is
+    returned in x. */
+void scs_mul_ui(scs_ptr, const unsigned int);
+
+/** Square. Result is normalised */
+void scs_square(scs_ptr result, scs_ptr x);
+
+/** Fused multiply-and-add (ab+c);   Result is normalised
+\warning This function has not been tested thoroughly */
+void scs_fma(scs_ptr result,  scs_ptr a,  scs_ptr b,  scs_ptr c);
+
+/**@}*/ /* end doxygen group for Multiplication functions*/
+
+
+
+
+
+/* ****************************************************************** */
+/**@name Divisions */ /**@{*/
+
+/** SCS inverse.  
+Stores 1/x in result. Result is normalised 
+
+@warning This function is known not to work for most precisions: it
+performs a fixed number of Newton-Raphson iterations (two), starting
+with a FP number (53 bits), so provides roughly 210 bits of
+precision. It should be modified to perform more iterations if more
+precision is needed.
+*/
+void scs_inv(scs_ptr result, scs_ptr x);
+
+/** SCS division. Computes x/y. Result is normalised 
+@warning This function is known not to work for most precisions: it
+performs a fixed number of Newton-Raphson iterations (two), starting
+with a FP number (53 bits), so provides roughly 210 bits of
+precision. It should be modified to perform more iterations if more
+precision is needed.
+*/
+void scs_div(scs_ptr result, scs_ptr x, scs_ptr y);
+
+
+/** SCS division by 2. Computes x/2. Result is normalised */ 
+void scs_div_2(scs_t x);
+
+/**@}*/ /* end doxygen group for division functions*/
+
+
+
+
+
+/* ****************************************************************** */
+/**@name Functions for testing purpose */ /**@{*/
+
+
+#ifdef HAVE_LIBGMP
+/** Convert a SCS number into a GMP MPF (multiple precision,
+   floating-point) number. Should be exact if the target number has
+   more precision than the SCS number, otherwise the rounding is
+   unspecified (the conversion uses MPF functions) */
+void scs_get_mpf(scs_ptr, mpf_t);
+#endif
+
+
+
+#ifdef HAVE_MPFR_H 
+/**  Convert a SCS number into a MPFR (multiple precision,
+   floating-point) number. Should be exact if the target number has
+   more precision than the SCS number, otherwise should be correctly
+   rounded (the conversion uses MPFR functions). Not heavily tested
+   though */
+void scs_get_mpfr(scs_ptr, mpfr_t);
+#endif
+
+
+/**@}*/ /* end doxygen group for functions for testing purpose */
+
+#endif /* INCLUDE_SCS */
+
+
+
+
+