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 }