double
hypot(double x, double y)
{
static double const zero=0;
static double const one=1;
static double const small=1.0E-18; /* fl(1+small)==1 */
static int const ibig=30; /* fl(1+2**(2*ibig))==1 */
double t;
double r;
int exp;
if(finite(x)) {
if(finite(y)) {
x=copysign(x,one);
y=copysign(y,one);
if(y > x) {
t=x; x=y; y=t;
}
if(x == zero) return(zero);
if(y == zero) return(x);
exp= logb(x);
if(exp-(int)logb(y) > ibig ) {
/* raise inexact flag and return |x| */
(void volatile)(one+small);
return(x);
}
/* start computing sqrt(x^2 + y^2) */
r=x-y;
if(r>y) { /* x/y > 2 */
r=x/y;
r=r+sqrt(one+r*r);
} else { /* 1 <= x/y <= 2 */
r/=y; t=r*(r+2.0);
r+=t/(sqrt2+sqrt(2.0+t));
r+=r2p1lo; r+=r2p1hi;
}
r=y/r;
return(x+r);
}
else if(y==y) /* y is +-INF */
return(copysign(y,one));
else
return(y); /* y is NaN and x is finite */
} else if(x==x) {
return (copysign(x,one)); /* x is +-INF */
} else if(finite(y)) {
return(x); /* x is NaN, y is finite */
#if !defined(vax)&&!defined(tahoe)
} else if(y!=y) {
return(y); /* x and y is NaN */
#endif /* !defined(vax)&&!defined(tahoe) */
} else {
return(copysign(y,one)); /* y is INF */
}
}
void test_fp_exp( void )
{
#if __STDC_VERSION__ >= 199901L
printf( "Testing C99 exponential/logarithm functions...\n" );
/* Small test values taken from SPECFUN tests */
VERIFY( CompDbl( expm1( 0.0 ), 0.0 ) );
VERIFY( CompDbl( expm1( 1.0 ), E-1.0 ) );
VERIFY( CompDbl( expm1( 1.0E-3 ), 1.00050016670834166E-3 ) );
VERIFY( CompDbl( expm1( 1.0E-9 ), 1.00000000050000000e-9 ) );
VERIFY( CompDbl( expm1( -1.0E-3 ), -9.9950016662500833194E-4 ) );
VERIFY( CompDbl( expm1( -1.0E-9 ), -9.9999999950000000016e-10 ) );
VERIFY( CompDbl( log1p( 0.02 ), 0.019803 ) );
VERIFY( CompDbl( log1p( 0.03 ), 0.029559 ) );
VERIFY( CompDbl( log1p( 0.10 ), 0.095310 ) );
/* logb/ilogb tests */
VERIFY( logb( 0.0 ) == INFINITY );
VERIFY( CompDbl( logb( 1024.0 ), 10.0 ) );
VERIFY( CompDbl( logb( 1025.0 ), 10.0 ) );
VERIFY( CompDbl( logb( 1.0/1024.0 ), -10.0 ) );
VERIFY( CompDbl( logb( -1025.0 ), 10.0 ) );
VERIFY( ilogb( 0.0 ) == FP_ILOGB0 );
VERIFY( ilogb( NAN ) == FP_ILOGBNAN );
VERIFY( ilogb( 1024.0 ) == 10 );
VERIFY( ilogb( 1025.0 ) == 10 );
VERIFY( ilogb( 1.0/1024.0 ) == -10 );
VERIFY( ilogb( -1025.0 ) == 10 );
#endif
}
void test_logb()
{
static_assert((std::is_same<decltype(logb((double)0)), double>::value), "");
static_assert((std::is_same<decltype(logbf(0)), float>::value), "");
static_assert((std::is_same<decltype(logbl(0)), long double>::value), "");
assert(logb(1) == 0);
}
double bitand(double x, double y) {
if(logb(x) > 31 || logb(y) > 31) {
return NAN;
} else {
return (double) ( (unsigned int) x & (unsigned int ) y ) ;
}
}
TEST(math, logb) {
ASSERT_EQ(-HUGE_VAL, logb(0.0));
ASSERT_TRUE(isnan(logb(nan(""))));
ASSERT_TRUE(isinf(logb(HUGE_VAL)));
ASSERT_EQ(0.0, logb(1.0));
ASSERT_EQ(3.0, logb(10.0));
}
/*
* Extra precision variant, returning struct {double a, b;};
* log(x) = a+b to 63 bits, with a is rounded to 26 bits.
*/
struct Double
__log__D(double x)
{
int m;
int j;
double F;
double f;
double g;
double q;
double u;
double v;
double u2;
static double const one = 1.0;
volatile double u1;
struct Double r;
/* Argument reduction: 1 <= g < 2; x/2^m = g; */
/* y = F*(1 + f/F) for |f| <= 2^-8 */
m = logb(x);
g = ldexp(x, -m);
if (_IEEE && m == -1022) {
j = logb(g), m += j;
g = ldexp(g, -j);
}
j = N*(g-1) + .5;
F = (1.0/N) * j + 1;
f = g - F;
g = 1/(2*F+f);
u = 2*f*g;
v = u*u;
q = u*v*(A1 + v*(A2 + v*(A3 + v*A4)));
if (m | j)
u1 = u + 513, u1 -= 513;
else
u1 = u, TRUNC(u1);
u2 = (2.0*(f - F*u1) - u1*f) * g;
u1 += m*logF_head[N] + logF_head[j];
u2 += logF_tail[j]; u2 += q;
u2 += logF_tail[N]*m;
r.a = u1 + u2; /* Only difference is here */
TRUNC(r.a);
r.b = (u1 - r.a) + u2;
return (r);
}
// Проверяет, можно ли считать таблицей нечто с адресом p и шириной элементов N
static bool slow_check_for_data_table (int N, byte *p, uint32 &type, BYTE *&table_start, BYTE *&table_end, byte *bufstart, byte *bufend, byte *buf, uint64 &offset, Buffer &ReorderingBuffer)
{
// Сначала сканируем назад, начиная с p, в поисках начала таблицы
int useless;
table_start = search_for_table_boundary (-N, p, bufstart, bufend, useless);
// Затем сканируем вперёд, начиная с table_start, в поисках конца таблицы
table_end = search_for_table_boundary (N, table_start, bufstart, bufend, useless);
// +разрешить таблицы с широкими столбцами и небольшим числом строк (sqrt(N)*rows >= X)
// +учитывать расстояние до предыдущей таблицы для оптимизации конечного уровня сжатия
// улучшать оценку для столбцов с фиксированной разницей между элементами (типа 8,16,24,32...)
// считать количество байтов, энтропия которых уменьшилась от вычитания [как минимум на два бита]
// Теперь выясняем, достаточно ли хороша эта таблица для того, чтобы её стоило закодировать
int rows = (table_end-table_start)/N;
int useful = rows - useless; // количество полезных строк таблицы
double skipBits = logb(mymax(table_start-bufstart,1)); // сколько бит придётся потратить на кодирование поля skip
stat ((slow_checks++, verbose>1 && printf ("Slow check %08x-%08x (%d*%d+%d)\n", int(table_start-buf+offset), int(table_end-buf+offset), N, useful, useless)));
if (useful*sqrt((double)N) > 30+4*skipBits) {
stat ((table_count++, table_sumlen += N*rows, table_skipBits+=skipBits));
stat (verbose>0 && printf("%08x-%08x %d*%d ", int(table_start-buf+offset), int(table_end-buf+offset), N, rows));
// Определить какие столбцы нужно вычесть, а какие являются иммутабельными.
// Вычесть вычитаемое и собрать иммутабельные столбцы в начале таблицы (для удобства работы lz77)
bool doDiff[MAX_ELEMENT_SIZE], immutable[MAX_ELEMENT_SIZE];
analyze_table (N, table_start, rows, doDiff, immutable);
diff_table (N, table_start, rows, doDiff);
reorder_table (N, table_start, rows, immutable, ReorderingBuffer);
type = encode_type (N, doDiff, immutable);
stat (verbose>0 && printf("\n"));
return TRUE;
}
return FALSE;
}
void recursive_treewrite(std::ostream &out, radix_tree_node<std::string, std::unordered_set<zsr::filecount>> *n, zsr::offset treestart)
{
static int nwritten = 0;
logb(++nwritten);
treesize nval = 0;
if (n->m_children.count("") && n->m_children[""]->m_value) nval = n->m_children[""]->m_value->second.size();
treesize nchild = 0;
for (const std::pair<const std::string, radix_tree_node<std::string, std::unordered_set<zsr::filecount>> *> child : n->m_children) if (child.first != "" && child.second) nchild++; // TODO Probably a faster way?
zsr::serialize(out, nchild);
std::deque<zsr::offset> childpos{};
for (const std::pair<const std::string, radix_tree_node<std::string, std::unordered_set<zsr::filecount>> *> child : n->m_children)
{
if (child.first == "" || ! child.second) continue;
uint16_t namelen = child.first.size();
zsr::serialize(out, namelen);
out.write(&child.first[0], namelen);
childpos.push_back(static_cast<zsr::offset>(out.tellp()));
zsr::serialize(out, ptrfill);
}
zsr::serialize(out, nval);
if (n->m_children.count("") && n->m_children[""]->m_value)
for (const zsr::filecount &i : n->m_children[""]->m_value->second) zsr::serialize(out, i);
for (const std::pair<const std::string, radix_tree_node<std::string, std::unordered_set<zsr::filecount>> *> child : n->m_children)
{
if (child.first == "" || ! child.second) continue;
zsr::offset childstart = static_cast<zsr::offset>(out.tellp()) - treestart;
out.seekp(childpos.front());
zsr::serialize(out, childstart);
out.seekp(0, std::ios_base::end);
recursive_treewrite(out, child.second, treestart);
childpos.pop_front();
}
}
int main() {
double x = 1.0;
double y = 1.0;
int i = 1;
acosh(x);
asinh(x);
atanh(x);
cbrt(x);
expm1(x);
erf(x);
erfc(x);
isnan(x);
j0(x);
j1(x);
jn(i,x);
ilogb(x);
logb(x);
log1p(x);
rint(x);
y0(x);
y1(x);
yn(i,x);
# ifdef _THREAD_SAFE
gamma_r(x,&i);
lgamma_r(x,&i);
# else
gamma(x);
lgamma(x);
# endif
hypot(x,y);
nextafter(x,y);
remainder(x,y);
scalb(x,y);
return 0;
}
double
log1p(double x)
{
static const double zero=0.0, negone= -1.0, one=1.0,
half=1.0/2.0, small=1.0E-20; /* 1+small == 1 */
double z,s,t,c;
int k;
#if !defined(__vax__)&&!defined(tahoe)
if(x!=x) return(x); /* x is NaN */
#endif /* !defined(__vax__)&&!defined(tahoe) */
if(finite(x)) {
if( x > negone ) {
/* argument reduction */
if(copysign(x,one)<small) return(x);
k=logb(one+x); z=scalb(x,-k); t=scalb(one,-k);
if(z+t >= sqrt2 )
{ k += 1 ; z *= half; t *= half; }
t += negone; x = z + t;
c = (t-x)+z ; /* correction term for x */
/* compute log(1+x) */
s = x/(2+x); t = x*x*half;
c += (k*ln2lo-c*x);
z = c+s*(t+__log__L(s*s));
x += (z - t) ;
return(k*ln2hi+x);
}
/* end of if (x > negone) */
else {
#if defined(__vax__)||defined(tahoe)
if ( x == negone )
return (infnan(-ERANGE)); /* -INF */
else
return (infnan(EDOM)); /* NaN */
#else /* defined(__vax__)||defined(tahoe) */
/* x = -1, return -INF with signal */
if ( x == negone ) return( negone/zero );
/* negative argument for log, return NaN with signal */
else return ( zero / zero );
#endif /* defined(__vax__)||defined(tahoe) */
}
}
/* end of if (finite(x)) */
/* log(-INF) is NaN */
else if(x<0)
return(zero/zero);
/* log(+INF) is INF */
else return(x);
}
int ilogb(double x)
{
if (x == 0.0)
return FP_ILOGB0;
if (isinf(x))
return INT_MAX;
if (isnan(x))
return FP_ILOGBNAN;
return (int) logb(x);
}
static double sc(basis_s *v,simplex *s, int k, int j) {
/* amount by which to scale up vector, for reduce_inner */
double labound;
static int lscale;
static double max_scale,
ldetbound,
Sb;
if (j<10) {
labound = logb(v->sqa)/2;
max_scale = exact_bits - labound - 0.66*(k-2)-1 -DELIFT;
if (max_scale<1) {
warning(-10, overshot exact arithmetic);
max_scale = 1;
}
if (j==0) {
int i;
neighbor *sni;
basis_s *snib;
ldetbound = DELIFT;
Sb = 0;
for (i=k-1,sni=s->neigh+k-1;i>0;i--,sni--) {
snib = sni->basis;
Sb += snib->sqb;
ldetbound += logb(snib->sqb)/2 + 1;
ldetbound -= snib->lscale;
}
}
}
if (ldetbound - v->lscale + logb(v->sqb)/2 + 1 < 0) {
DEBS(-2)
DEBTR(-2) DEBEXP(-2, ldetbound)
print_simplex_f(s, DFILE, &print_neighbor_full);
print_basis(DFILE,v);
EDEBS
return 0;
} else {
static void BM_math_logb(int iters) {
StartBenchmarkTiming();
d = 0.0;
v = 1234.0;
for (int i = 0; i < iters; ++i) {
d += logb(v);
}
StopBenchmarkTiming();
}
int
ilogb(double x)
{
if (x == 0)
return FP_ILOGB0;
if (x != x)
return FP_ILOGBNAN;
if (!finite(x))
return INT_MAX;
return (int)logb(x);
}
double entropy(float a[], int n)
{
float ent=0;
int i=0;
for(i=0;i<n;i++){
if (a[i] == 0){
ent += 0;
}else{
ent -= a[i] * logb(a[i],2);
}
}
return ent;
}
/*
bitwise complement for use with .Call to bitFlip masked to bitWidth
*/
SEXP bitFlip(SEXP a, SEXP bitWidth )
{
PROTECT (a = AS_NUMERIC(a) ) ;
PROTECT (bitWidth = AS_INTEGER(bitWidth) ) ;
int n = LENGTH(a);
int *xbitWidth = INTEGER_POINTER(bitWidth);
double *xa = NUMERIC_POINTER(a);
unsigned int mask = ( unsigned int ) -1 >> (32 - *xbitWidth);
SEXP aflip = PROTECT(NEW_NUMERIC(n));
double *xaflip = NUMERIC_POINTER(aflip);
for (int i=0; i<n; i++ ) {
if ( !R_FINITE(xa[i]) || logb(xa[i])>31 )
xaflip[i]=NA_REAL ;
else {
// in case of a negative, cast twice;
unsigned int tmp = xa[i] < 0 ? (int) xa[i] : (unsigned) xa[i];
xaflip[i]=(double) ( ~tmp & mask ) ;
}
}
UNPROTECT(3) ;
return (aflip) ;
}
static void
F(compile_test) (void)
{
TYPE a, b, c = 1.0;
complex TYPE d;
int i;
int saved_count;
long int j;
long long int k;
a = cos (cos (x));
b = acos (acos (a));
a = sin (sin (x));
b = asin (asin (a));
a = tan (tan (x));
b = atan (atan (a));
c = atan2 (atan2 (a, c), atan2 (b, x));
a = cosh (cosh (x));
b = acosh (acosh (a));
a = sinh (sinh (x));
b = asinh (asinh (a));
a = tanh (tanh (x));
b = atanh (atanh (a));
a = exp (exp (x));
b = log (log (a));
a = log10 (log10 (x));
b = ldexp (ldexp (a, 1), 5);
a = frexp (frexp (x, &i), &i);
b = expm1 (expm1 (a));
a = log1p (log1p (x));
b = logb (logb (a));
a = exp2 (exp2 (x));
b = log2 (log2 (a));
a = pow (pow (x, a), pow (c, b));
b = sqrt (sqrt (a));
a = hypot (hypot (x, b), hypot (c, a));
b = cbrt (cbrt (a));
a = ceil (ceil (x));
b = fabs (fabs (a));
a = floor (floor (x));
b = fmod (fmod (a, b), fmod (c, x));
a = nearbyint (nearbyint (x));
b = round (round (a));
a = trunc (trunc (x));
b = remquo (remquo (a, b, &i), remquo (c, x, &i), &i);
j = lrint (x) + lround (a);
k = llrint (b) + llround (c);
a = erf (erf (x));
b = erfc (erfc (a));
a = tgamma (tgamma (x));
b = lgamma (lgamma (a));
a = rint (rint (x));
b = nextafter (nextafter (a, b), nextafter (c, x));
a = nextdown (nextdown (a));
b = nexttoward (nexttoward (x, a), c);
a = nextup (nextup (a));
b = remainder (remainder (a, b), remainder (c, x));
a = scalb (scalb (x, a), (TYPE) (6));
k = scalbn (a, 7) + scalbln (c, 10l);
i = ilogb (x);
j = llogb (x);
a = fdim (fdim (x, a), fdim (c, b));
b = fmax (fmax (a, x), fmax (c, b));
a = fmin (fmin (x, a), fmin (c, b));
b = fma (sin (a), sin (x), sin (c));
a = totalorder (totalorder (x, b), totalorder (c, x));
b = totalordermag (totalordermag (x, a), totalordermag (c, x));
#ifdef TEST_INT
a = atan2 (i, b);
b = remquo (i, a, &i);
c = fma (i, b, i);
a = pow (i, c);
#endif
x = a + b + c + i + j + k;
saved_count = count;
if (ccount != 0)
ccount = -10000;
d = cos (cos (z));
z = acos (acos (d));
d = sin (sin (z));
z = asin (asin (d));
d = tan (tan (z));
z = atan (atan (d));
d = cosh (cosh (z));
z = acosh (acosh (d));
d = sinh (sinh (z));
z = asinh (asinh (d));
d = tanh (tanh (z));
z = atanh (atanh (d));
d = exp (exp (z));
z = log (log (d));
d = sqrt (sqrt (z));
z = conj (conj (d));
d = fabs (conj (a));
z = pow (pow (a, d), pow (b, z));
d = cproj (cproj (z));
z += fabs (cproj (a));
a = carg (carg (z));
b = creal (creal (d));
c = cimag (cimag (z));
x += a + b + c + i + j + k;
z += d;
if (saved_count != count)
count = -10000;
if (0)
{
a = cos (y);
a = acos (y);
a = sin (y);
a = asin (y);
a = tan (y);
a = atan (y);
a = atan2 (y, y);
a = cosh (y);
a = acosh (y);
a = sinh (y);
a = asinh (y);
a = tanh (y);
a = atanh (y);
a = exp (y);
a = log (y);
a = log10 (y);
a = ldexp (y, 5);
a = frexp (y, &i);
a = expm1 (y);
a = log1p (y);
a = logb (y);
a = exp2 (y);
a = log2 (y);
a = pow (y, y);
a = sqrt (y);
a = hypot (y, y);
a = cbrt (y);
a = ceil (y);
a = fabs (y);
a = floor (y);
a = fmod (y, y);
a = nearbyint (y);
a = round (y);
a = trunc (y);
a = remquo (y, y, &i);
j = lrint (y) + lround (y);
k = llrint (y) + llround (y);
a = erf (y);
a = erfc (y);
a = tgamma (y);
a = lgamma (y);
a = rint (y);
a = nextafter (y, y);
a = nexttoward (y, y);
a = remainder (y, y);
a = scalb (y, (const TYPE) (6));
k = scalbn (y, 7) + scalbln (y, 10l);
i = ilogb (y);
j = llogb (y);
a = fdim (y, y);
a = fmax (y, y);
a = fmin (y, y);
a = fma (y, y, y);
a = totalorder (y, y);
a = totalordermag (y, y);
#ifdef TEST_INT
a = atan2 (i, y);
a = remquo (i, y, &i);
a = fma (i, y, i);
a = pow (i, y);
#endif
d = cos ((const complex TYPE) z);
d = acos ((const complex TYPE) z);
d = sin ((const complex TYPE) z);
d = asin ((const complex TYPE) z);
d = tan ((const complex TYPE) z);
d = atan ((const complex TYPE) z);
d = cosh ((const complex TYPE) z);
d = acosh ((const complex TYPE) z);
d = sinh ((const complex TYPE) z);
d = asinh ((const complex TYPE) z);
d = tanh ((const complex TYPE) z);
d = atanh ((const complex TYPE) z);
d = exp ((const complex TYPE) z);
d = log ((const complex TYPE) z);
d = sqrt ((const complex TYPE) z);
d = pow ((const complex TYPE) z, (const complex TYPE) z);
d = fabs ((const complex TYPE) z);
d = carg ((const complex TYPE) z);
d = creal ((const complex TYPE) z);
d = cimag ((const complex TYPE) z);
d = conj ((const complex TYPE) z);
d = cproj ((const complex TYPE) z);
}
}
double fmod ( double x, double y )
{
int iclx,icly; /* classify results of x,y */
int32_t iscx,iscy,idiff; /* logb values and difference */
int i; /* loop variable */
double absy,x1,y1,z; /* local floating-point variables */
double rslt;
fenv_t OldEnv;
hexdouble OldEnvironment;
int newexc;
FEGETENVD( OldEnvironment.d );
FESETENVD( 0.0 );
__NOOP;
__NOOP;
OldEnv = OldEnvironment.i.lo;
iclx = __fpclassifyd(x);
icly = __fpclassifyd(y);
if (likely((iclx & icly) >= FP_NORMAL)) { /* x,y both nonzero finite case */
x1 = __FABS(x); /* work with absolute values */
absy = __FABS(y);
if (absy > x1) {
rslt = x; /* trivial case */
goto ret;
}
else { /* nontrivial case requires reduction */
iscx = (int32_t) logb(x1); /* get binary exponents of |x| and |y| */
iscy = (int32_t) logb(absy);
idiff = iscx - iscy; /* exponent difference */
if (idiff != 0) { /* exponent of x1 > exponent of y1 */
y1 = scalbn(absy,-iscy); /* scale |y| to unit binade */
x1 = scalbn(x1,-iscx); /* ditto for |x| */
for (i = idiff; i != 0; i--) { /* begin remainder loop */
if ((z = x1 - y1) >= 0) { /* nonzero remainder step result */
x1 = z; /* update remainder (x1) */
}
x1 += x1; /* shift (by doubling) remainder */
} /* end of remainder loop */
x1 = scalbn(x1,iscy); /* scale result to binade of |y| */
} /* remainder exponent >= exponent of y */
if (x1 >= absy) { /* last step to obtain modulus */
x1 -= absy;
}
} /* x1 is |result| */
if (x < 0.0)
x1 = -x1; /* modulus if x is negative */
rslt = x1;
goto ret;
} /* end of x,y both nonzero finite case */
else if ((iclx <= FP_QNAN) || (icly <= FP_QNAN)) {
rslt = x+y; /* at least one NaN operand */
goto ret;
}
else if ((iclx == FP_INFINITE)||(icly == FP_ZERO)) { /* invalid result */
rslt = nan(REM_NAN);
OldEnvironment.i.lo |= SET_INVALID;
FESETENVD_GRP ( OldEnvironment.d );
goto ret;
}
else /* trivial cases (finite MOD infinite */
rslt = x; /* or zero REM nonzero) with *quo = 0 */
ret:
FEGETENVD_GRP (OldEnvironment.d );
newexc = OldEnvironment.i.lo & FE_ALL_EXCEPT;
OldEnvironment.i.lo = OldEnv;
if ((newexc & FE_INVALID) != 0)
OldEnvironment.i.lo |= SET_INVALID;
OldEnvironment.i.lo |= newexc & ( FE_INEXACT | FE_DIVBYZERO | FE_UNDERFLOW | FE_OVERFLOW );
FESETENVD_GRP (OldEnvironment.d );
return rslt;
}
__attribute__((weak)) long double logbl(long double x) { return logb((double)x); }
CAMLprim value math_logb(value x) {
CAMLparam1(x);
CAMLreturn(caml_copy_double(logb(Double_val(x))));
}
void
math (double d, int *ex, double *dp)
{
acos (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 8 } */
acosh (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 10 } */
asin (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 12 } */
asinh (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 14 } */
atan (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 16 } */
atanh (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 18 } */
atan2 (d, d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 20 } */
cbrt (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 22 } */
ceil (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 24 } */
copysign (d, d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 26 } */
cos (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 28 } */
cosh (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 30 } */
erf (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 32 } */
erfc (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 34 } */
exp (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 36 } */
exp2 (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 38 } */
expm1 (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 40 } */
fabs (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 42 } */
fdim (d, d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 44 } */
floor (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 46 } */
fma (d, d, d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 48 } */
fmax (d, d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 50 } */
fmin (d, d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 52 } */
fmod (d, d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 54 } */
frexp (d, ex); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 56 } */
hypot (d, d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 58 } */
/* We don't generate the warning for ilogb. */
ilogb (d);
ldexp (d, *ex); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 62 } */
lgamma (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 64 } */
llrint (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 66 } */
llround (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 68 } */
log (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 70 } */
log10 (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 72 } */
log1p (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 74 } */
log2 (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 76 } */
logb (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 78 } */
lrint (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 80 } */
lround (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 82 } */
modf (d, dp); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 84 } */
nan (""); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 86 } */
nearbyint (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 88 } */
nextafter (d, d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 90 } */
nexttoward (d, 20.0L); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 92 } */
pow (d, d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 94 } */
remainder (d, d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 96 } */
remquo (d, d, ex); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 98 } */
rint (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 100 } */
round (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 102 } */
scalbln (d, 100L); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 104 } */
scalbn (d, 100); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 106 } */
sin (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 108 } */
sinh (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 110 } */
sincos (d, dp, dp); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 112 } */
sqrt (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 114 } */
tan (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 116 } */
tanh (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 118 } */
tgamma (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 120 } */
trunc (d); /* { dg-warning "incompatible implicit" } */
/* { dg-message "include ..math.h.." "" { target *-*-* } 122 } */
}
__device__ void double_precision_math_functions() {
int iX;
double fX, fY;
acos(1.0);
acosh(1.0);
asin(0.0);
asinh(0.0);
atan(0.0);
atan2(0.0, 1.0);
atanh(0.0);
cbrt(0.0);
ceil(0.0);
copysign(1.0, -2.0);
cos(0.0);
cosh(0.0);
cospi(0.0);
cyl_bessel_i0(0.0);
cyl_bessel_i1(0.0);
erf(0.0);
erfc(0.0);
erfcinv(2.0);
erfcx(0.0);
erfinv(1.0);
exp(0.0);
exp10(0.0);
exp2(0.0);
expm1(0.0);
fabs(1.0);
fdim(1.0, 0.0);
floor(0.0);
fma(1.0, 2.0, 3.0);
fmax(0.0, 0.0);
fmin(0.0, 0.0);
fmod(0.0, 1.0);
frexp(0.0, &iX);
hypot(1.0, 0.0);
ilogb(1.0);
isfinite(0.0);
isinf(0.0);
isnan(0.0);
j0(0.0);
j1(0.0);
jn(-1.0, 1.0);
ldexp(0.0, 0);
lgamma(1.0);
llrint(0.0);
llround(0.0);
log(1.0);
log10(1.0);
log1p(-1.0);
log2(1.0);
logb(1.0);
lrint(0.0);
lround(0.0);
modf(0.0, &fX);
nan("1");
nearbyint(0.0);
nextafter(0.0, 0.0);
fX = 1.0;
norm(1, &fX);
norm3d(1.0, 0.0, 0.0);
norm4d(1.0, 0.0, 0.0, 0.0);
normcdf(0.0);
normcdfinv(1.0);
pow(1.0, 0.0);
rcbrt(1.0);
remainder(2.0, 1.0);
remquo(1.0, 2.0, &iX);
rhypot(0.0, 1.0);
rint(1.0);
fX = 1.0;
rnorm(1, &fX);
rnorm3d(0.0, 0.0, 1.0);
rnorm4d(0.0, 0.0, 0.0, 1.0);
round(0.0);
rsqrt(1.0);
scalbln(0.0, 1);
scalbn(0.0, 1);
signbit(1.0);
sin(0.0);
sincos(0.0, &fX, &fY);
sincospi(0.0, &fX, &fY);
sinh(0.0);
sinpi(0.0);
sqrt(0.0);
tan(0.0);
tanh(0.0);
tgamma(2.0);
trunc(0.0);
y0(1.0);
y1(1.0);
yn(1, 1.0);
}
double logbl( double x ) {
return (double)logb((double) x);
}
double
log(double x)
{
int m, j;
double F;
double f;
double g;
double q;
double u;
double u2;
double v;
static double const zero = 0.0;
static double const one = 1.0;
volatile double u1;
/* Catch special cases */
if (x <= 0) {
if (_IEEE && x == zero) /* log(0) = -Inf */
return (-one/zero);
else if (_IEEE) /* log(neg) = NaN */
return (zero/zero);
else if (x == zero) /* NOT REACHED IF _IEEE */
return (infnan(-ERANGE));
else
return (infnan(EDOM));
} else if (!finite(x)) {
if (_IEEE) /* x = NaN, Inf */
return (x+x);
else
return (infnan(ERANGE));
}
/* Argument reduction: 1 <= g < 2; x/2^m = g; */
/* y = F*(1 + f/F) for |f| <= 2^-8 */
m = logb(x);
g = ldexp(x, -m);
if (_IEEE && m == -1022) {
j = logb(g), m += j;
g = ldexp(g, -j);
}
j = N*(g-1) + .5;
F = (1.0/N) * j + 1; /* F*128 is an integer in [128, 512] */
f = g - F;
/* Approximate expansion for log(1+f/F) ~= u + q */
g = 1/(2*F+f);
u = 2*f*g;
v = u*u;
q = u*v*(A1 + v*(A2 + v*(A3 + v*A4)));
/* case 1: u1 = u rounded to 2^-43 absolute. Since u < 2^-8,
* u1 has at most 35 bits, and F*u1 is exact, as F has < 8 bits.
* It also adds exactly to |m*log2_hi + log_F_head[j] | < 750
*/
if (m | j)
u1 = u + 513, u1 -= 513;
/* case 2: |1-x| < 1/256. The m- and j- dependent terms are zero;
* u1 = u to 24 bits.
*/
else
u1 = u, TRUNC(u1);
u2 = (2.0*(f - F*u1) - u1*f) * g;
/* u1 + u2 = 2f/(2F+f) to extra precision. */
/* log(x) = log(2^m*F*(1+f/F)) = */
/* (m*log2_hi+logF_head[j]+u1) + (m*log2_lo+logF_tail[j]+q); */
/* (exact) + (tiny) */
u1 += m*logF_head[N] + logF_head[j]; /* exact */
u2 = (u2 + logF_tail[j]) + q; /* tiny */
u2 += logF_tail[N]*m;
return (u1 + u2);
}
long double
logbl (long double x)
{
return logb (x);
}
long double logbl(long double x) { return logb((double)x); }
float logbf (float x)
{
return (float) logb( (double)x );
}
double
atan2(double y, double x)
{
static const double zero=0, one=1, small=1.0E-9, big=1.0E18;
double t,z,signy,signx,hi,lo;
int k,m;
#if !defined(__vax__)&&!defined(tahoe)
/* if x or y is NAN */
if(x!=x) return(x); if(y!=y) return(y);
#endif /* !defined(__vax__)&&!defined(tahoe) */
/* copy down the sign of y and x */
signy = copysign(one,y) ;
signx = copysign(one,x) ;
/* if x is 1.0, goto begin */
if(x==1) { y=copysign(y,one); t=y; if(finite(t)) goto begin;}
/* when y = 0 */
if(y==zero) return((signx==one)?y:copysign(PI,signy));
/* when x = 0 */
if(x==zero) return(copysign(PIo2,signy));
/* when x is INF */
if(!finite(x))
if(!finite(y))
return(copysign((signx==one)?PIo4:3*PIo4,signy));
else
return(copysign((signx==one)?zero:PI,signy));
/* when y is INF */
if(!finite(y)) return(copysign(PIo2,signy));
/* compute y/x */
x=copysign(x,one);
y=copysign(y,one);
if((m=(k=logb(y))-logb(x)) > 60) t=big+big;
else if(m < -80 ) t=y/x;
else { t = y/x ; y = scalb(y,-k); x=scalb(x,-k); }
/* begin argument reduction */
begin:
if (t < 2.4375) {
/* truncate 4(t+1/16) to integer for branching */
k = 4 * (t+0.0625);
switch (k) {
/* t is in [0,7/16] */
case 0:
case 1:
if (t < small)
{ big + small ; /* raise inexact flag */
return (copysign((signx>zero)?t:PI-t,signy)); }
hi = zero; lo = zero; break;
/* t is in [7/16,11/16] */
case 2:
hi = athfhi; lo = athflo;
z = x+x;
t = ( (y+y) - x ) / ( z + y ); break;
/* t is in [11/16,19/16] */
case 3:
case 4:
hi = PIo4; lo = zero;
t = ( y - x ) / ( x + y ); break;
/* t is in [19/16,39/16] */
default:
hi = at1fhi; lo = at1flo;
z = y-x; y=y+y+y; t = x+x;
t = ( (z+z)-x ) / ( t + y ); break;
}
}
/* end of if (t < 2.4375) */
else
{
hi = PIo2; lo = zero;
/* t is in [2.4375, big] */
if (t <= big) t = - x / y;
/* t is in [big, INF] */
else
{ big+small; /* raise inexact flag */
t = zero; }
}
/* end of argument reduction */
/* compute atan(t) for t in [-.4375, .4375] */
z = t*t;
#if defined(__vax__)||defined(tahoe)
z = t*(z*(a1+z*(a2+z*(a3+z*(a4+z*(a5+z*(a6+z*(a7+z*(a8+
z*(a9+z*(a10+z*(a11+z*a12))))))))))));
#else /* defined(__vax__)||defined(tahoe) */
z = t*(z*(a1+z*(a2+z*(a3+z*(a4+z*(a5+z*(a6+z*(a7+z*(a8+
z*(a9+z*(a10+z*a11)))))))))));
#endif /* defined(__vax__)||defined(tahoe) */
z = lo - z; z += t; z += hi;
return(copysign((signx>zero)?z:PI-z,signy));
}
/*
* SMPcDProd()
*/
int
SMPcDProd(SMPmatrix *Matrix, SPcomplex *pMantissa, int *pExponent)
{
double re, im, x, y, z;
int p;
spDeterminant( (void *)Matrix, &p, &re, &im);
#ifndef M_LN2
#define M_LN2 0.69314718055994530942
#endif
#ifndef M_LN10
#define M_LN10 2.30258509299404568402
#endif
#ifdef debug_print
printf("Determinant 10: (%20g,%20g)^%d\n", re, im, p);
#endif
/* Convert base 10 numbers to base 2 numbers, for comparison */
y = p * M_LN10 / M_LN2;
x = (int) y;
y -= x;
/* ASSERT
* x = integral part of exponent, y = fraction part of exponent
*/
/* Fold in the fractional part */
#ifdef debug_print
printf(" ** base10 -> base2 int = %g, frac = %20g\n", x, y);
#endif
z = pow(2.0, y);
re *= z;
im *= z;
#ifdef debug_print
printf(" ** multiplier = %20g\n", z);
#endif
/* Re-normalize (re or im may be > 2.0 or both < 1.0 */
if (re != 0.0) {
y = logb(re);
if (im != 0.0)
z = logb(im);
else
z = 0;
} else if (im != 0.0) {
z = logb(im);
y = 0;
} else {
/* Singular */
/*printf("10 -> singular\n");*/
y = 0;
z = 0;
}
#ifdef debug_print
printf(" ** renormalize changes = %g,%g\n", y, z);
#endif
if (y < z)
y = z;
*pExponent = x + y;
x = scalbn(re, (int) -y);
z = scalbn(im, (int) -y);
#ifdef debug_print
printf(" ** values are: re %g, im %g, y %g, re' %g, im' %g\n",
re, im, y, x, z);
#endif
pMantissa->real = scalbn(re, (int) -y);
pMantissa->imag = scalbn(im, (int) -y);
#ifdef debug_print
printf("Determinant 10->2: (%20g,%20g)^%d\n", pMantissa->real,
pMantissa->imag, *pExponent);
#endif
return spError( (void *)Matrix );
}
void
domath (void)
{
#ifndef NO_DOUBLE
double f1;
double f2;
int i1;
f1 = acos (0.0);
fprintf( stdout, "acos : %f\n", f1);
f1 = acosh (0.0);
fprintf( stdout, "acosh : %f\n", f1);
f1 = asin (1.0);
fprintf( stdout, "asin : %f\n", f1);
f1 = asinh (1.0);
fprintf( stdout, "asinh : %f\n", f1);
f1 = atan (M_PI_4);
fprintf( stdout, "atan : %f\n", f1);
f1 = atan2 (2.3, 2.3);
fprintf( stdout, "atan2 : %f\n", f1);
f1 = atanh (1.0);
fprintf( stdout, "atanh : %f\n", f1);
f1 = cbrt (27.0);
fprintf( stdout, "cbrt : %f\n", f1);
f1 = ceil (3.5);
fprintf( stdout, "ceil : %f\n", f1);
f1 = copysign (3.5, -2.5);
fprintf( stdout, "copysign : %f\n", f1);
f1 = cos (M_PI_2);
fprintf( stdout, "cos : %f\n", f1);
f1 = cosh (M_PI_2);
fprintf( stdout, "cosh : %f\n", f1);
f1 = erf (42.0);
fprintf( stdout, "erf : %f\n", f1);
f1 = erfc (42.0);
fprintf( stdout, "erfc : %f\n", f1);
f1 = exp (0.42);
fprintf( stdout, "exp : %f\n", f1);
f1 = exp2 (0.42);
fprintf( stdout, "exp2 : %f\n", f1);
f1 = expm1 (0.00042);
fprintf( stdout, "expm1 : %f\n", f1);
f1 = fabs (-1.123);
fprintf( stdout, "fabs : %f\n", f1);
f1 = fdim (1.123, 2.123);
fprintf( stdout, "fdim : %f\n", f1);
f1 = floor (0.5);
fprintf( stdout, "floor : %f\n", f1);
f1 = floor (-0.5);
fprintf( stdout, "floor : %f\n", f1);
f1 = fma (2.1, 2.2, 3.01);
fprintf( stdout, "fma : %f\n", f1);
f1 = fmax (-0.42, 0.42);
fprintf( stdout, "fmax : %f\n", f1);
f1 = fmin (-0.42, 0.42);
fprintf( stdout, "fmin : %f\n", f1);
f1 = fmod (42.0, 3.0);
fprintf( stdout, "fmod : %f\n", f1);
/* no type-specific variant */
i1 = fpclassify(1.0);
fprintf( stdout, "fpclassify : %d\n", i1);
f1 = frexp (42.0, &i1);
fprintf( stdout, "frexp : %f\n", f1);
f1 = hypot (42.0, 42.0);
fprintf( stdout, "hypot : %f\n", f1);
i1 = ilogb (42.0);
fprintf( stdout, "ilogb : %d\n", i1);
/* no type-specific variant */
i1 = isfinite(3.0);
fprintf( stdout, "isfinite : %d\n", i1);
/* no type-specific variant */
i1 = isgreater(3.0, 3.1);
fprintf( stdout, "isgreater : %d\n", i1);
/* no type-specific variant */
i1 = isgreaterequal(3.0, 3.1);
fprintf( stdout, "isgreaterequal : %d\n", i1);
/* no type-specific variant */
i1 = isinf(3.0);
fprintf( stdout, "isinf : %d\n", i1);
/* no type-specific variant */
i1 = isless(3.0, 3.1);
fprintf( stdout, "isless : %d\n", i1);
/* no type-specific variant */
i1 = islessequal(3.0, 3.1);
fprintf( stdout, "islessequal : %d\n", i1);
/* no type-specific variant */
i1 = islessgreater(3.0, 3.1);
fprintf( stdout, "islessgreater : %d\n", i1);
/* no type-specific variant */
i1 = isnan(0.0);
fprintf( stdout, "isnan : %d\n", i1);
/* no type-specific variant */
i1 = isnormal(3.0);
fprintf( stdout, "isnormal : %d\n", i1);
/* no type-specific variant */
f1 = isunordered(1.0, 2.0);
fprintf( stdout, "isunordered : %d\n", i1);
f1 = j0 (1.2);
fprintf( stdout, "j0 : %f\n", f1);
f1 = j1 (1.2);
fprintf( stdout, "j1 : %f\n", f1);
f1 = jn (2,1.2);
fprintf( stdout, "jn : %f\n", f1);
f1 = ldexp (1.2,3);
fprintf( stdout, "ldexp : %f\n", f1);
f1 = lgamma (42.0);
fprintf( stdout, "lgamma : %f\n", f1);
f1 = llrint (-0.5);
fprintf( stdout, "llrint : %f\n", f1);
f1 = llrint (0.5);
fprintf( stdout, "llrint : %f\n", f1);
f1 = llround (-0.5);
fprintf( stdout, "lround : %f\n", f1);
f1 = llround (0.5);
fprintf( stdout, "lround : %f\n", f1);
f1 = log (42.0);
fprintf( stdout, "log : %f\n", f1);
f1 = log10 (42.0);
fprintf( stdout, "log10 : %f\n", f1);
f1 = log1p (42.0);
fprintf( stdout, "log1p : %f\n", f1);
f1 = log2 (42.0);
fprintf( stdout, "log2 : %f\n", f1);
f1 = logb (42.0);
fprintf( stdout, "logb : %f\n", f1);
f1 = lrint (-0.5);
fprintf( stdout, "lrint : %f\n", f1);
f1 = lrint (0.5);
fprintf( stdout, "lrint : %f\n", f1);
f1 = lround (-0.5);
fprintf( stdout, "lround : %f\n", f1);
f1 = lround (0.5);
fprintf( stdout, "lround : %f\n", f1);
f1 = modf (42.0,&f2);
fprintf( stdout, "lmodf : %f\n", f1);
f1 = nan ("");
fprintf( stdout, "nan : %f\n", f1);
f1 = nearbyint (1.5);
fprintf( stdout, "nearbyint : %f\n", f1);
f1 = nextafter (1.5,2.0);
fprintf( stdout, "nextafter : %f\n", f1);
f1 = pow (3.01, 2.0);
fprintf( stdout, "pow : %f\n", f1);
f1 = remainder (3.01,2.0);
fprintf( stdout, "remainder : %f\n", f1);
f1 = remquo (29.0,3.0,&i1);
fprintf( stdout, "remquo : %f\n", f1);
f1 = rint (0.5);
fprintf( stdout, "rint : %f\n", f1);
f1 = rint (-0.5);
fprintf( stdout, "rint : %f\n", f1);
f1 = round (0.5);
fprintf( stdout, "round : %f\n", f1);
f1 = round (-0.5);
fprintf( stdout, "round : %f\n", f1);
f1 = scalbln (1.2,3);
fprintf( stdout, "scalbln : %f\n", f1);
f1 = scalbn (1.2,3);
fprintf( stdout, "scalbn : %f\n", f1);
/* no type-specific variant */
i1 = signbit(1.0);
fprintf( stdout, "signbit : %i\n", i1);
f1 = sin (M_PI_4);
fprintf( stdout, "sin : %f\n", f1);
f1 = sinh (M_PI_4);
fprintf( stdout, "sinh : %f\n", f1);
f1 = sqrt (9.0);
fprintf( stdout, "sqrt : %f\n", f1);
f1 = tan (M_PI_4);
fprintf( stdout, "tan : %f\n", f1);
f1 = tanh (M_PI_4);
fprintf( stdout, "tanh : %f\n", f1);
f1 = tgamma (2.1);
fprintf( stdout, "tgamma : %f\n", f1);
f1 = trunc (3.5);
fprintf( stdout, "trunc : %f\n", f1);
f1 = y0 (1.2);
fprintf( stdout, "y0 : %f\n", f1);
f1 = y1 (1.2);
fprintf( stdout, "y1 : %f\n", f1);
f1 = yn (3,1.2);
fprintf( stdout, "yn : %f\n", f1);
#endif
}
