crmf 0.1.1 → 0.1.2

data/ext/crlibm-1.0beta5/prepare

@@ -0,0 +1,20 @@
+#!/bin/sh --
+
+# This script is inspired by the prepare script distributed with with
+#   mpfr, which is inspired by the prepare script distributed with Mutt.
+
+if aclocal && autoheader && autoconf&& automake --add-missing -c && autoconf && ./configure $@
+then
+  echo
+  echo "The crlibm source code was successfully prepared."
+  echo "Type 'make' to build crlibm."
+  echo
+  echo "Note: if you want to reconfigure crlibm, you can now use the 'configure'"
+  echo "script directly; you do not need the 'prepare' script any longer."
+  echo
+else
+  echo
+  echo "Some part of the preparation process failed."
+  echo
+  exit 1
+fi

data/ext/crlibm-1.0beta5/rem_pio2_accurate.c

@@ -0,0 +1,219 @@
+/*
+ * rem_pio2, used in correctly rounded trigonometric functions
+ *
+ * Author : Catherine Daramy, David Defour, Florent de Dinechin
+ *
+ * This file is part of the crlibm library developed by the Arenaire
+ * project at Ecole Normale Superieure de Lyon
+ *
+ * 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.  
+*/
+
+/**
+ * This file include functions to compute y=x-N*pi/2 and return the last two bits of N
+ * in order to know which quadrant we are considering.
+ *
+ * We use an scs representation to compute it by Payne and Hanek methods. For more information
+ * you can read K. C. Ng research report from Sun Microsystems:
+ * "Argument reduction for huge argument: Good to the last bit" (July 13, 1992)
+ *
+ */
+#include "rem_pio2_accurate.h"
+
+
+/**
+ * Case X_IND = -1:
+ *               0 
+ *           2 ^ 
+ *  X    :   <> |--| |--| |--|   0   0 0 0 0
+ *  2/Pi :   <> |--| |--| |--| |--| .....
+ *
+ *  Case X_IND = 0:
+ *                   0 
+ *                2 ^ 
+ *  X    :   |--| <> |--| |--|   0   0 0 0 0
+ *  2/Pi :        <> |--| |--| |--| |--| .....
+ *
+ *  Case X_IND = 1:
+ *                       0 
+ *                    2 ^ 
+ *  X    :   |--| |--| <> |--| |--|   0   0 0 0 0
+ *  2/Pi :             <> |--| |--| |--| |--| .....
+ *
+ *  Case ...
+ * 
+ *  Step 1:
+ *
+ *   Compute r = X . 2/Pi where: 
+ *    - r[0] hold the integer part. (if x>0 or the once complement integer part if x<0 )
+ *    - r[1] to r[SCS_NB_WORDS+2] hold the reduced part
+ *      the 3 extra 30 bits are here to prevent possible 
+ *      cancellation due to a number x too close to a
+ *      multiple of Pi/2.
+ *
+ *  Step 2:
+ *   Compute result = (r[1] ... r[SCS_NB_WORDS]) . Pi/2.
+ *       
+ * description of local variables :
+ * - ind : where to start multiplying into 2opi table
+ *
+ */
+
+/* TODO OPTIM 
+   better 64-bit multiplication, see in scs_mult */
+
+int rem_pio2_scs(scs_ptr result, const scs_ptr x){
+  uint64_t r[SCS_NB_WORDS+3], tmp;
+  unsigned int N;
+  /* result r[0],...,r[10] could store till 300 bits of precision */
+  /* that is really enough for computing the reduced argument */
+  int sign, i, j, ind;
+  int *two_over_pi_pt;
+
+  if ((X_EXP != 1)||(X_IND < -1)){
+    scs_set(result, x);
+    return 0;
+  }
+  
+
+
+  /* Compute the product |x| * 2/Pi */
+  if ((X_IND == -1)){
+    /* In this case we consider number between ]-1,+1[    */
+    /* we may use simpler algorithm such as Cody And Waite */
+    r[0] =  0;    r[1] =  0;
+    r[2] =  (uint64_t)(two_over_pi[0]) * X_HW[0];
+    r[3] = ((uint64_t)(two_over_pi[0]) * X_HW[1]
+	   +(uint64_t)(two_over_pi[1]) * X_HW[0]);
+    if(X_HW[2] == 0){
+      for(i=4; i<(SCS_NB_WORDS+3); i++){   
+	r[i] = ((uint64_t)(two_over_pi[i-3]) * X_HW[1]
+	       +(uint64_t)(two_over_pi[i-2]) * X_HW[0]);
+      }}else {
+	for(i=4; i<(SCS_NB_WORDS+3); i++){   
+	  r[i] = ((uint64_t)(two_over_pi[i-4]) * X_HW[2]
+		 +(uint64_t)(two_over_pi[i-3]) * X_HW[1]
+		 +(uint64_t)(two_over_pi[i-2]) * X_HW[0]);
+	}
+      }
+  }else {
+    if (X_IND == 0){
+      r[0] =  0;
+      r[1] =  (uint64_t)(two_over_pi[0]) * X_HW[0];
+      r[2] = ((uint64_t)(two_over_pi[0]) * X_HW[1]
+	     +(uint64_t)(two_over_pi[1]) * X_HW[0]);
+      if(X_HW[2] == 0){
+	for(i=3; i<(SCS_NB_WORDS+3); i++){   
+	  r[i] = ((uint64_t)(two_over_pi[i-2]) * X_HW[1]
+		 +(uint64_t)(two_over_pi[i-1]) * X_HW[0]);
+	}}else {
+	  for(i=3; i<(SCS_NB_WORDS+3); i++){   
+	    r[i] = ((uint64_t)(two_over_pi[i-3]) * X_HW[2]
+		   +(uint64_t)(two_over_pi[i-2]) * X_HW[1]
+		   +(uint64_t)(two_over_pi[i-1]) * X_HW[0]);
+	  }}
+    }else {
+      if (X_IND == 1){
+	r[0] =  (uint64_t)(two_over_pi[0]) * X_HW[0];
+	r[1] = ((uint64_t)(two_over_pi[0]) * X_HW[1]
+	       +(uint64_t)(two_over_pi[1]) * X_HW[0]);
+	if(X_HW[2] == 0){
+	  for(i=2; i<(SCS_NB_WORDS+3); i++){   
+	    r[i] = ((uint64_t)(two_over_pi[i-1]) * X_HW[1]
+		   +(uint64_t)(two_over_pi[ i ]) * X_HW[0]);
+	  }}else {
+	    for(i=2; i<(SCS_NB_WORDS+3); i++){   
+	      r[i] = ((uint64_t)(two_over_pi[i-2]) * X_HW[2]
+		     +(uint64_t)(two_over_pi[i-1]) * X_HW[1]
+		     +(uint64_t)(two_over_pi[ i ]) * X_HW[0]);
+	    }}
+      }else {
+	if (X_IND == 2){
+  	  r[0] = ((uint64_t)(two_over_pi[0]) * X_HW[1]
+		 +(uint64_t)(two_over_pi[1]) * X_HW[0]);
+	  if(X_HW[2] == 0){
+	    for(i=1; i<(SCS_NB_WORDS+3); i++){   
+	      r[i] = ((uint64_t)(two_over_pi[ i ]) * X_HW[1]
+		     +(uint64_t)(two_over_pi[i+1]) * X_HW[0]);
+	    }}else {
+	      for(i=1; i<(SCS_NB_WORDS+3); i++){   
+		r[i] = ((uint64_t)(two_over_pi[i-1]) * X_HW[2]
+		       +(uint64_t)(two_over_pi[ i ]) * X_HW[1]
+		       +(uint64_t)(two_over_pi[i+1]) * X_HW[0]);
+	      }}
+	}else {
+	  ind = (X_IND - 3);
+	  two_over_pi_pt = (int*)&(two_over_pi[ind]);
+	  if(X_HW[2] == 0){
+	    for(i=0; i<(SCS_NB_WORDS+3); i++){   
+	      r[i] = ((uint64_t)(two_over_pi_pt[i+1]) * X_HW[1]
+		     +(uint64_t)(two_over_pi_pt[i+2]) * X_HW[0]);
+	    }}else {
+	      for(i=0; i<(SCS_NB_WORDS+3); i++){   
+		r[i] = ((uint64_t)(two_over_pi_pt[ i ]) * X_HW[2]
+		       +(uint64_t)(two_over_pi_pt[i+1]) * X_HW[1]
+		       +(uint64_t)(two_over_pi_pt[i+2]) * X_HW[0]);
+	      }
+	    }
+	}
+      }
+    }
+  }
+      
+  /* Carry propagate */
+  r[SCS_NB_WORDS+1] += r[SCS_NB_WORDS+2]>>30;
+  for(i=(SCS_NB_WORDS+1); i>0; i--) {tmp=r[i]>>30;   r[i-1] += tmp;  r[i] -= (tmp<<30);}  
+      
+  /* The integer part is in r[0] */
+  N = (unsigned int)(r[0]);
+#if 0
+  printf("r[0] = %d\n", N);
+#endif
+
+
+  /* test if the reduced part is bigger than Pi/4 */
+  if (r[1] > (uint64_t)(SCS_RADIX)/2){
+    N += 1;
+    sign = -1;
+    for(i=1; i<(SCS_NB_WORDS+3); i++) { r[i]=((~(unsigned int)(r[i])) & 0x3fffffff);}
+  } 
+  else
+    sign = 1; 
+
+
+  /* Now we get the reduce argument and check for possible
+   * cancellation By Kahan algorithm we will have at most 2 digits
+   * of cancellations r[1] and r[2] in the worst case.
+   */    
+  if (r[1] == 0)
+    if (r[2] == 0) i = 3;
+    else           i = 2;
+  else             i = 1;
+
+  for(j=0; j<SCS_NB_WORDS; j++) { R_HW[j] = (unsigned int)(r[i+j]);}
+
+
+  R_EXP   = 1;
+  R_IND   = -i;
+  R_SGN   = sign*X_SGN; 
+  
+  /* Last step :
+   *   Multiplication by pi/2
+   */
+  scs_mul(result, Pio2_ptr, result);
+  return X_SGN*N;
+}
+ 
+

data/ext/crlibm-1.0beta5/rem_pio2_accurate.h

@@ -0,0 +1,53 @@
+/*
+ * 2oPi[] store in hexadecimal 48 digits, each keeping 30 bits of
+ * 2/pi. 
+ * We then store 1440 bits of 2/pi. which is for sure a bit too much ...
+ */
+ 
+#include "crlibm.h"
+#include "crlibm_private.h"
+
+
+static const int two_over_pi[]=
+  {0x28be60db, 0x24e44152, 0x27f09d5f, 0x11f534dd,
+   0x3036d8a5, 0x1993c439, 0x0107f945, 0x23abdebb,
+   0x31586dc9, 0x06e3a424, 0x374b8019, 0x092eea09,
+   0x3464873f, 0x21deb1cb, 0x04a69cfb, 0x288235f5,
+   0x0baed121, 0x0e99c702, 0x1ad17df9, 0x013991d6,
+   0x0e60d4ce, 0x1f49c845, 0x3e2ef7e4, 0x283b1ff8,
+   0x25fff781, 0x1980fef2, 0x3c462d68, 0x0a6d1f6d,
+   0x0d9fb3c9, 0x3cb09b74, 0x3d18fd9a, 0x1e5fea2d,
+   0x1d49eeb1, 0x3ebe5f17, 0x2cf41ce7, 0x378a5292,
+   0x3a9afed7, 0x3b11f8d5, 0x3421580c, 0x3046fc7b,
+   0x1aeafc33, 0x3bc209af, 0x10d876a7, 0x2391615e,
+   0x3986c219, 0x199855f1, 0x1281a102, 0x0dffd880};
+
+
+
+
+/*
+ * This scs number store 211 bits of pi/2 
+ */
+static const scs Pio2=
+  {{0x00000001, 0x2487ed51, 0x042d1846, 0x26263314,
+    0x1701b839, 0x28948127, 0x01114cf9, 0x23a0105d},
+    DB_ONE,  0,   1 };
+
+#define Pio2_ptr  (scs_ptr)(& Pio2)
+
+
+
+#if 0
+
+/*
+ * This scs number store 211 bits of pi/4 
+ */
+static const scs Pio4=
+/* ~7.853982e-01 */ 
+{{0x3243f6a8, 0x22168c23, 0x1313198a, 0x0b80dc1c, 
+0x344a4093, 0x2088a67c, 0x31d0082e, 0x3ea63b13},
+DB_ONE,  -1,   1 };
+
+#define Pio4_ptr  ((scs_ptr)(& Pio4))
+
+#endif

data/ext/crlibm-1.0beta5/scs_lib/AUTHORS

@@ -0,0 +1,3 @@
+scslib, the Software Carry-Save multiple-precision library
+
+Authors: David Defour, Catherine Daramy, Florent de Dinechin