intervals 0.3.56

data/ext/crlibm/scs_lib/tests/tbx_timing.h

@@ -0,0 +1,102 @@
+#ifndef TBX_TIMING_H
+#define TBX_TIMING_H
+
+#include <sys/types.h>
+#include <sys/time.h>
+#if defined(CRLIBM_TYPECPU_ITANIUM) && defined(__INTEL_COMPILER)
+#include<ia64intrin.h>
+#endif
+
+/*
+ * For the user interested in High resolution timer, to my knowledge 
+ * the best library is "RTAI", unfortunately it works only on Linux OS
+ */
+
+
+typedef union u_tbx_tick
+{
+  unsigned long long tick;
+
+  struct
+  {
+    unsigned long low;
+    unsigned long high;
+  } sub;
+
+  struct timeval timev;
+} tbx_tick_t, *p_tbx_tick_t;
+
+
+#if defined(CRLIBM_TYPECPU_ITANIUM) && defined(__GNUC__) && !defined(__INTEL_COMPILER)
+ 
+#define TBX_GET_TICK(t) \
+   __asm__ __volatile__("mov %0=ar.itc" : "=r"((t).tick) :: "memory")
+#define TBX_TICK_RAW_DIFF(t1, t2)    ((t2).tick - (t1).tick)
+
+
+#elif defined(CRLIBM_TYPECPU_ITANIUM) && defined(__HPCC__)
+/* Never tested, currently nobody defines __HPCC__.
+  It should work on HPUX machines using HP compiler */
+#include<machine/sys/inline.h>/* to move up of course */
+#define TBX_GET_TICK(t) \
+   t.tick=_Asm_mov_from_ar(_AREG_ITC)
+#define TBX_TICK_RAW_DIFF(t1, t2)    ((t2).tick - (t1).tick )
+
+
+#elif defined(CRLIBM_TYPECPU_ITANIUM) && defined(__INTEL_COMPILER)
+#define TBX_GET_TICK(t)    t.tick=__getReg(_IA64_REG_AR_ITC)   
+#define TBX_TICK_RAW_DIFF(t1, t2)    ((t2).tick - (t1).tick)
+
+
+
+#elif (defined(CRLIBM_TYPECPU_AMD64) || defined(CRLIBM_TYPECPU_X86)) \
+    && defined(__GNUC__) && !defined(__INTEL_COMPILER)
+#define TBX_GET_TICK(time)                \
+        __asm__ __volatile__(             \
+                "xorl %%eax,%%eax\n\t"    \
+                "cpuid\n\t"               \
+                "rdtsc\n\t"               \
+                "movl %%eax,(%0)\n\t"     \
+                "movl %%edx,4(%0)\n\t"    \
+                "xorl %%eax,%%eax\n\t"    \
+                "cpuid\n\t"               \
+                : /* no output */         \
+                : "S"(&time.tick)         \
+                : "eax", "ebx", "ecx", "edx", "memory")
+#define TBX_TICK_RAW_DIFF(t1, t2)    ((t2).tick - (t1).tick)
+
+
+#elif defined(CRLIBM_TYPECPU_ALPHA)  && defined(__GNUC__)
+#define TBX_GET_TICK(t) \
+   __asm__ volatile("rpcc %0\n\t" : "=r"((t).tick))
+#define TBX_TICK_RAW_DIFF(t1, t2) \
+   (((t2).tick & 0xFFFFFFFF) - ((t1).tick & 0xFFFFFFFF))
+
+
+#elif defined(CRLIBM_TYPECPU_SPARC)  && defined(__GNUC__)
+#define TBX_GET_TICK(t) \
+    (t).tick = gethrtime()
+#define TBX_TICK_RAW_DIFF(t1, t2) \
+   ((t2).tick  - (t1).tick)
+
+
+
+#else  /* generic case */
+
+#define TIMING_USES_GETTIMEOFDAY 1  /* inform the test functions that timings are inaccurate */
+#define TBX_GET_TICK(t) \
+   gettimeofday(&(t).timev, 0)
+#define TBX_TICK_RAW_DIFF(t1, t2) \
+   ((t2.timev.tv_sec * 1000000L + t2.timev.tv_usec) - \
+    (t1.timev.tv_sec * 1000000L + t1.timev.tv_usec))
+
+#endif
+
+#define TBX_TICK_DIFF(t1, t2) (TBX_TICK_RAW_DIFF(t1, t2) - tbx_residual + 1)
+#define TBX_TIMING_DELAY(t1, t2) tbx_tick2usec(TBX_TICK_DIFF(t1, t2))
+
+extern unsigned long long tbx_residual;
+extern tbx_tick_t         tbx_new_event;
+extern tbx_tick_t         tbx_last_event;
+
+#endif /* TBX_TIMING_H */

data/ext/crlibm/scs_lib/wrapper_scs.h

@@ -0,0 +1,486 @@
+extern "C"
+{
+#include "scs.h"
+}
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include <iostream.h>
+
+#ifndef SCS_WRAPPER_CPP
+#define SCS_WRAPPER_CPP 1
+
+extern "C" int scs_cmp_mant(scs_ptr , scs_ptr);
+
+class Scs{
+ private:
+    scs scsnb; 
+
+ public:
+    /* Constructors */
+    Scs(){}
+    Scs(double &d){scs_set_d(&scsnb, d);}
+    Scs(int &i){scs_set_si(&scsnb, i);}
+    Scs(const Scs& nb);
+    ~Scs(){}; 
+
+    /* Mutators */
+    void scs_set_sign (int i)     {this->scsnb.sign = i;}
+    void scs_set_index(int i)     {this->scsnb.index = i;}
+    void scs_set_excep(double d)  {this->scsnb.exception.d = d;}
+    void scs_set_words(unsigned int word[SCS_NB_WORDS]){for(int i=0; i<SCS_NB_WORDS; i++) this->scsnb.h_word[i] = word[i];}
+
+    /* Cast */
+    operator double();
+    operator int();
+
+
+    /* Negation */
+    Scs operator-() const;
+    friend Scs fabs(const Scs &a);
+
+    /* Assignment */
+    Scs &operator=(const Scs &nb1);
+    Scs &operator=(const double nb1);
+    Scs &operator=(const int i){scs_set_si(&scsnb, i);}
+
+    /* Addition */
+    friend Scs operator+(Scs &nb1,Scs &nb2);
+    friend Scs operator+(Scs &nb1, const double &nb2);
+    friend Scs operator+(const double &nb1,Scs &nb2);
+    void operator+=(Scs &nb);
+    void operator+=(const double nb);
+
+    /* Subtraction */
+    friend Scs operator-(Scs &nb1,Scs &nb2);
+    friend Scs operator-(Scs &nb1, const double &nb2);
+    friend Scs operator-(const double &nb1,Scs &nb2);
+    void operator-=(Scs &nb);
+    void operator-=(const double nb);
+
+    /* Multiplication */
+    friend Scs operator*(Scs &nb1,Scs &nb2);
+    friend Scs operator*(Scs &nb1, const double &nb2);
+    friend Scs operator*(const double &nb1,Scs &nb2);
+    friend Scs operator*(Scs &nb1, const int &nb2);
+    friend Scs operator*(const int &nb1,Scs &nb2);
+    void operator*=(Scs &nb);
+    void operator*=(const double nb);
+    void operator*=(const int nb);
+
+    /* Multiplication */
+    friend Scs operator/(Scs &nb1,Scs &nb2);
+    friend Scs operator/(Scs &nb1, const double &nb2);
+    friend Scs operator/(const double &nb1,Scs &nb2);
+    void operator/=(Scs &nb);
+    void operator/=(const double nb);
+
+    /* Comparisons */
+    friend bool operator==(Scs &nb1,Scs &nb2);
+    friend bool operator!=(Scs &nb1,Scs &nb2);
+    friend bool operator<=(Scs &nb1,Scs &nb2);
+    friend bool operator>=(Scs &nb1,Scs &nb2);
+    friend bool operator<(Scs &nb1,Scs &nb2);
+    friend bool operator>(Scs &nb1,Scs &nb2);
+
+    /* Random Number */
+    Scs rand(void);
+
+    /* Input/Output */
+    friend ostream& operator<<(ostream &s, const Scs &a);
+    friend istream& operator>>(istream &s, Scs &a);
+
+};
+
+
+
+
+/**************
+ * CONSTRUCTOR
+ **************/
+Scs::Scs(const Scs& nb){
+  unsigned int i;
+  
+  for(i=0; i<SCS_NB_WORDS; i++)
+    this->scsnb.h_word[i] = nb.scsnb.h_word[i];
+
+  this->scsnb.exception.d = nb.scsnb.exception.d;
+  this->scsnb.index = nb.scsnb.index;
+  this->scsnb.sign = nb.scsnb.sign;
+}
+
+/**************
+ * CAST
+ **************/
+inline Scs::operator double() {
+    double d;
+    scs_get_d(&d, &(this->scsnb));
+    return d;
+}
+inline Scs::operator int() {
+    double d;
+    scs_get_d(&d, &(this->scsnb));
+    return ((int)d);
+}
+
+ 
+
+/**************    
+ * ASSIGNATION
+ **************/
+inline Scs &Scs::operator=(const Scs& nb){
+  unsigned int i;
+  
+  for(i=0; i<SCS_NB_WORDS; i++)
+    scsnb.h_word[i] = nb.scsnb.h_word[i];
+
+  scsnb.exception.d = nb.scsnb.exception.d;
+  scsnb.index = nb.scsnb.index;
+  scsnb.sign = nb.scsnb.sign;
+  
+  return *this;
+}
+inline Scs &Scs::operator=(const double nb){
+    scs_set_d(&(this->scsnb), nb);
+    return *this;
+}
+inline Scs fabs(const Scs &a){
+    Scs res(a);
+    res.scsnb.sign = 1;
+    return res;
+}
+
+
+/************
+ * ADDITION
+ ************/
+inline Scs operator+(Scs &nb1,Scs &nb2){
+    Scs res;    scs_add(&(res.scsnb), &(nb1.scsnb), &(nb2.scsnb));
+    return res;
+}
+inline Scs operator+(Scs &nb1,const double &nb2){
+    Scs res, op;
+    scs_set_d(&(op.scsnb), nb2);
+    scs_add(&(res.scsnb), &(nb1.scsnb), &(op.scsnb));
+    return res;
+}
+inline Scs operator+(const double &nb1, Scs &nb2){
+    Scs res, op;
+    scs_set_d(&(op.scsnb), nb1);
+    scs_add(&(res.scsnb), &(nb2.scsnb), &(op.scsnb));
+    return res;
+}
+void inline Scs::operator+=(Scs &nb) {
+    scs_add(&(this->scsnb), &(this->scsnb), &(nb.scsnb));
+}
+void inline Scs::operator+=(const double nb) {
+    Scs op;
+    scs_set_d(&(op.scsnb), nb);
+    scs_add(&(this->scsnb), &(this->scsnb), &(op.scsnb));
+}
+
+
+
+
+/**************
+ * SUBTRACTION
+ **************/
+inline Scs operator-(Scs &nb1,Scs &nb2){
+    Scs res;    scs_sub(&(res.scsnb), &(nb1.scsnb), &(nb2.scsnb));
+    return res;
+}
+inline Scs operator-(Scs &nb1,const double &nb2){
+    Scs res, op;
+    scs_set_d(&(op.scsnb), nb2);
+    scs_sub(&(res.scsnb), &(nb1.scsnb), &(op.scsnb));
+    return res;
+}
+inline Scs operator-(const double &nb1, Scs &nb2){
+    Scs res, op;
+    scs_set_d(&(op.scsnb), nb1);
+    scs_sub(&(res.scsnb), &(nb2.scsnb), &(op.scsnb));
+    return res;
+}
+void inline Scs::operator-=(Scs &nb) {
+    scs_sub(&(this->scsnb), &(this->scsnb), &(nb.scsnb));
+}
+void inline Scs::operator-=(const double nb) {
+    Scs op;
+    scs_set_d(&(op.scsnb), nb);
+    scs_sub(&(this->scsnb), &(this->scsnb), &(op.scsnb));
+}
+
+
+
+/*****************
+ * MULTIPLICATION
+ *****************/
+inline Scs operator*(Scs &nb1,Scs &nb2){
+    Scs res;    scs_mul(&(res.scsnb), &(nb1.scsnb), &(nb2.scsnb));
+    return res;
+}
+inline Scs operator*(Scs &nb1,const double &nb2){
+    Scs res, op;
+    scs_set_d(&(op.scsnb), nb2);
+    scs_mul(&(res.scsnb), &(nb1.scsnb), &(op.scsnb));
+    return res;
+}
+inline Scs operator*(const double &nb1, Scs &nb2){
+    Scs res, op;
+    scs_set_d(&(op.scsnb), nb1);
+    scs_mul(&(res.scsnb), &(nb2.scsnb), &(op.scsnb));
+    return res;
+}
+inline Scs operator*(Scs &nb1, const int &nb2){
+    Scs res;
+    scs_set(&(res.scsnb), &(nb1.scsnb));
+    scs_mul_ui(&(res.scsnb), nb2);
+    return res;
+}
+inline Scs operator*(const int &nb1, Scs &nb2){
+    Scs res;
+    scs_set(&(res.scsnb), &(nb2.scsnb));
+    scs_mul_ui(&(res.scsnb), nb1);
+    return res;
+}
+void inline Scs::operator*=(Scs &nb) {
+    scs_mul(&(this->scsnb), &(this->scsnb), &(nb.scsnb));
+}
+void inline Scs::operator*=(const double nb) {
+    Scs op;
+    scs_set_d(&(op.scsnb), nb);
+    scs_mul(&(this->scsnb), &(this->scsnb), &(op.scsnb));
+}
+void inline Scs::operator*=(const int nb) {
+    scs_mul_ui(&(this->scsnb), nb);
+}
+
+
+
+/*****************
+ * DIVISION
+ *****************/
+inline Scs operator/(Scs &nb1,Scs &nb2){
+    Scs res;    scs_div(&(res.scsnb), &(nb1.scsnb), &(nb2.scsnb));
+    return res;
+}
+inline Scs operator/(Scs &nb1, const double &nb2){
+    Scs res, op;
+    scs_set_d(&(op.scsnb), nb2);
+    scs_div(&(res.scsnb), &(nb1.scsnb), &(op.scsnb));
+    return res;
+}
+inline Scs operator/(const double &nb1, Scs &nb2){
+    Scs res, op;
+    scs_set_d(&(op.scsnb), nb1);
+    scs_div(&(res.scsnb), &(nb2.scsnb), &(op.scsnb));
+    return res;
+}
+void inline Scs::operator/=(Scs &nb) {
+    scs_div(&(this->scsnb), &(this->scsnb), &(nb.scsnb));
+}
+void inline Scs::operator/=(const double nb) {
+    Scs op;
+    scs_set_d(&(op.scsnb), nb);
+    scs_div(&(this->scsnb), &(this->scsnb), &(op.scsnb));
+}
+
+
+
+/*************
+ * COMPARISON
+ *************/
+inline bool operator==(Scs &nb1, Scs &nb2){
+  unsigned int i;
+  bool b=1;
+  
+  for(i=0; i<SCS_NB_WORDS; i++) 
+      if (nb1.scsnb.h_word[i] == nb2.scsnb.h_word[i]) b=0;
+  
+  return ((nb1.scsnb.exception.d == nb2.scsnb.exception.d)&&
+	  (nb1.scsnb.index == nb2.scsnb.index)&&
+	  (nb1.scsnb.sign  == nb2.scsnb.sign)&& b);
+}
+inline bool operator!=(Scs &nb1, Scs &nb2){
+    return !(nb1==nb2);
+}
+inline bool operator<=(Scs &nb1, Scs &nb2){
+    return ((nb1.scsnb.exception.d <= nb2.scsnb.exception.d)&&
+	    (nb1.scsnb.sign  <= nb2.scsnb.sign)&&
+	    ((nb1.scsnb.index < nb2.scsnb.index)||
+	     ((nb1.scsnb.index == nb2.scsnb.index)&&
+	      (scs_cmp_mant(&(nb1.scsnb), &(nb2.scsnb))<=0))));
+}
+inline bool operator>=(Scs &nb1, Scs &nb2){
+    return ((nb1.scsnb.exception.d >= nb2.scsnb.exception.d)&&
+	    (nb1.scsnb.sign  >= nb2.scsnb.sign)&&
+	    ((nb1.scsnb.index > nb2.scsnb.index)||
+	     ((nb1.scsnb.index == nb2.scsnb.index)&&
+	      (scs_cmp_mant(&(nb1.scsnb), &(nb2.scsnb))>=0))));
+}
+inline bool operator<(Scs &nb1, Scs &nb2){
+    return ((nb1.scsnb.exception.d <= nb2.scsnb.exception.d)&&
+	    (nb1.scsnb.sign  <= nb2.scsnb.sign)&&
+	    ((nb1.scsnb.index < nb2.scsnb.index)||
+	     ((nb1.scsnb.index == nb2.scsnb.index)&&
+	      (scs_cmp_mant(&(nb1.scsnb), &(nb2.scsnb))<0))));
+}
+inline bool operator>(Scs &nb1, Scs &nb2){
+    return ((nb1.scsnb.exception.d >= nb2.scsnb.exception.d)&&
+	    (nb1.scsnb.sign  >= nb2.scsnb.sign)&&
+	    ((nb1.scsnb.index > nb2.scsnb.index)||
+	     ((nb1.scsnb.index == nb2.scsnb.index)&&
+	      (scs_cmp_mant(&(nb1.scsnb), &(nb2.scsnb))>0))));
+}
+
+
+
+
+/****************
+ * RANDOM NUMBER
+ ****************/
+inline Scs Scs::rand(void){
+    scs_rand(&(this->scsnb), 200); 
+    return *this;
+}
+
+
+
+
+/*************** 
+ * OUTPUT (in hexadecimal)
+ ***************/ 
+ostream &operator<<(ostream &os, const Scs &a){
+    Scs aa, p, zer;
+    double d;
+    char buffer[10];
+    int e, exposant;
+    bool bb;
+
+    if (a.scsnb.exception.d != 1.){
+	os << (double)a.scsnb.exception.d;
+    }else {
+	if (a.scsnb.sign == -1)
+	    os << '-';
+	
+	aa = fabs(a);
+
+	/* Compute the exposant in radix 16 */
+	d = ((a.scsnb.index)*SCS_NB_BITS)/4;
+	e = 4*(int)floor(d);
+
+	p = 1;
+	p.scsnb.index = (int)floor(((double)e)/SCS_NB_BITS);
+	p.scsnb.h_word[0] = 1 << e - p.scsnb.index*SCS_NB_BITS;
+	exposant = (int)floor(d);
+	p /= 16;
+	exposant--;
+	while(p <= aa){
+	    p *= 16;
+	    exposant++;
+	}
+	p /= 16;
+	exposant--;
+	
+	/* Extract digits */
+	aa = aa / p;
+	sprintf(buffer,"%x", aa.scsnb.h_word[0]);
+	os << buffer << ".";
+	aa.scsnb.h_word[0] = 0;
+	aa *= 16;
+	
+	bb = 1;
+	while(bb){
+	    sprintf(buffer,"%x", aa.scsnb.h_word[0]);
+	    os << buffer;
+	    aa.scsnb.h_word[0] = 0;
+	    aa *= 16;
+
+	    bb = 0;
+	    for(int i=0; i<SCS_NB_WORDS; i++)
+		if (aa.scsnb.h_word[i] != 0) bb=1;
+	}
+
+	/* Write the exponent */
+	os << " x16^(" << exposant <<")";
+    } 
+    
+    return os;
+}
+
+
+/*************** 
+ * INPUT (in decimal)
+ ***************/ 
+istream& operator>>(istream &is, Scs &a){
+    char c;
+    int nd = 0;
+    int point = -1;
+    int ex;
+    bool done = false;
+    Scs r;
+
+    r = 0;
+
+    /* Skip any leading spaces */
+    do{
+	is>>c;
+    }while (c == ' ');
+
+    /* Read sign, digits, and exponent */
+    while (!done && (c != '\0')) {
+	if (c >= '0' && c <= '9') {
+	    int d = c - '0';
+	    r *= 10.0;
+	    r += d;
+	    nd++;
+	} else {
+	    switch (c) {
+	    case '.':
+		point = nd;
+		break;
+	    case '-':
+	    case '+':
+		if (nd > 0){
+		    a = 0;
+		    done = true;
+		    point = -1;
+		    ex = 0;
+		}
+		a.scsnb.sign = (c == '-') ? -1 : 1;
+		break;
+	    case 'E':
+	    case 'e':
+		is >> ex;
+		done = true;
+		break;
+	    default:
+		a = 0;
+		done = true;
+		point = -1;
+		ex = 0;
+	    }
+	}
+	is>>c;
+    }
+
+    if (point >= 0) 
+	ex -= (nd - point);
+    
+    
+    if (ex != 0) {
+	if (ex > 0)
+	    for(int i=0; i<ex; i++)
+		r *= 10;
+	if (ex < 0){
+	    Scs inv_ten, ten;
+	    ten = 10;
+	    scs_inv(&(inv_ten.scsnb), &(ten.scsnb) );
+	    for(int i=0; i>ex; i--)
+		r *= inv_ten;
+	}
+    }
+}
+#endif
+
+

data/ext/crlibm/scs_lib/zero_scs.c

@@ -0,0 +1,52 @@
+/** Function for setting an SCS number to zero 
+@file zero_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"
+
+
+/** Set a SCS number to zero.
+There should be a few simple functions in this library.
+ */
+
+
+
+void inline scs_zero(scs_ptr result) {
+  int i;
+
+  for(i=0; i<SCS_NB_WORDS; i++)
+    R_HW[i] = 0;
+
+  R_EXP = 0;
+  R_IND = 0;
+  R_SGN = 1;
+}
+
+
+

data/ext/crlibm/stamp-h.in

@@ -0,0 +1 @@
+timestamp

data/ext/crlibm/tests/Makefile.am

@@ -0,0 +1,43 @@
+## Process this file with automake to produce Makefile.in
+
+bin_PROGRAMS =  crlibm_testval crlibm_soaktest crlibm_testperf crlibm_blindtest crlibm_generate_test_vectors
+
+LDADD= $(top_builddir)/libcrlibm.a
+INCLUDES=-I$(top_srcdir)
+AM_CFLAGS = -g -O0 -std=c99
+../libcrlibm.a:
+	cd $(top_srcdir); make libcrlibm.a 
+
+crlibm_testval_SOURCES = test_val.c test_common.c test_common.h
+crlibm_soaktest_SOURCES = soak_test.c test_common.c test_common.h
+crlibm_testperf_SOURCES = test_perf.c test_common.c test_common.h
+crlibm_blindtest_SOURCES = blind_test.c test_common.c test_common.h
+crlibm_generate_test_vectors_SOURCES = generate_test_vectors.c test_common.c test_common.h
+
+check_exp: crlibm_blindtest
+	echo ./crlibm_blindtest exp.testdata>check_exp; chmod a+rx check_exp
+check_log: crlibm_blindtest
+	echo ./crlibm_blindtest log.testdata>check_log; chmod a+rx check_log
+check_log2: crlibm_blindtest
+	echo ./crlibm_blindtest log2.testdata>check_log2; chmod a+rx check_log2
+check_log10: crlibm_blindtest
+	echo ./crlibm_blindtest log10.testdata>check_log10; chmod a+rx check_log10
+check_sin: crlibm_blindtest
+	echo ./crlibm_blindtest sin.testdata>check_sin; chmod a+rx check_sin
+check_cos: crlibm_blindtest
+	echo ./crlibm_blindtest cos.testdata>check_cos; chmod a+rx check_cos
+check_tan: crlibm_blindtest
+	echo ./crlibm_blindtest tan.testdata>check_tan; chmod a+rx check_tan
+check_atan: crlibm_blindtest
+	echo ./crlibm_blindtest atan.testdata>check_atan; chmod a+rx check_atan
+check_sinh: crlibm_blindtest
+	echo ./crlibm_blindtest sinh.testdata>check_sinh; chmod a+rx check_sinh
+check_cosh: crlibm_blindtest
+	echo ./crlibm_blindtest cosh.testdata>check_cosh; chmod a+rx check_cosh
+
+CRLIBM_CHECKLIST = check_exp check_log check_log2 check_log10  check_sin check_cos check_tan check_atan check_sinh check_cosh
+TESTS = $(CRLIBM_CHECKLIST)
+
+EXTRA_DIST = exp.testdata log.testdata log2.testdata log10.testdata sin.testdata cos.testdata tan.testdata atan.testdata sinh.testdata cosh.testdata
+
+CLEANFILES = $(CRLIBM_CHECKLIST)