void TensorProductBasis<BASIS0,BASIS1>::apply_Tj(const int j, const V& x, V& y) const { y = x; V z(x); apply_Mj(j0(), z, y); for (int k = j0()+1; k <= j; k++) { apply_Mj(k, y, z); y.swap(z); } }
double jn (int n, double x) { int i; if (n < 0) { n = -n; x = -x; } if (n == 0) return j0(x); if (n == 1) return j1(x); if (x == 0.0) return 0.0; if (n <= x) { double a = j0(x), b = j1(x), tmp; for (i = 1; i < n; i++) { tmp = b; b = (2.0*i / x) * b - a; a = tmp; } return b; } else /* n > x */ { double a, b, xsq, t, tmp; xsq = x*x; for (t=0, i=n+16; i > n; i--) t = xsq / (2.0*i - t); t = x / (2.0*n - t); a = t; b = 1.0; for (i = n - 1; i > 0; i--) { tmp = b; b = (2.0*i / x ) * b - a; a = tmp; } return t*j0(x)/b; } }
TensorProductIndex<BASIS0,BASIS1> TensorProductBasis<BASIS0,BASIS1>::last_wavelet(const int j) { assert(j >= j0()); return TensorProductIndex<BASIS0,BASIS1>(BASIS0::last_wavelet(j), BASIS1::last_wavelet(j)); }
TensorProductIndex<BASIS0,BASIS1> TensorProductBasis<BASIS0,BASIS1>::first_generator(const int j) { assert(j >= j0()); return TensorProductIndex<BASIS0,BASIS1>(BASIS0::first_generator(j), BASIS1::first_generator(j)); }
double TransformErrFunction::evaluateReprojErrInt() { double reprojErr = 0; for(TransformSet::const_iterator ppTrans = transformSet_->begin(); ppTrans != transformSet_->end(); ppTrans++) { int j = ppTrans->first.im1Id(); int k = ppTrans->first.im2Id(); if(j != alignTo_ && k != alignTo_ && (j > minIdToRefine_ || k > minIdToRefine_)) { IdPair j0(j, alignTo_); IdPair k0(k, alignTo_); const Transform * Tj0 = (*transformSet_)[j0]->transform(); const Transform * Tk0 = (*transformSet_)[k0]->transform(); const Transform * Tjk = ppTrans->second->transform(); int inlierCount = ppTrans->second->correspondences().size(); Transform * Tj0_from_jk = Tk0->accumulate(Tjk); reprojErr += getErr(Tj0, Tj0_from_jk, inlierCount); delete Tj0_from_jk; } /*else if(j != alignTo_ ) //Here ppTrans->first.second == alignTo_. Don't calc reproj err for identity! { const Transform * Tj0 = ppTrans->second->transform(); reprojErr += getErr(Tj0); }*/ } return reprojErr * scaleCost_; //scaleCost_ makes errors initially about 1 }
void Foam::equationReader::evalDimsJ0DimCheck ( const equationReader * eqnReader, const label index, const label i, const label storageOffset, label& storeIndex, dimensionSet& xDims, dimensionSet sourceDims ) const { if ( !xDims.dimensionless() && dimensionSet::debug ) { WarningIn("equationReader::evalDimsJ0DimCheck") << "Dimension error thrown for operation [" << equationOperation::opName ( operator[](index)[i].operation() ) << "] in equation " << operator[](index).name() << ", given by:" << token::NL << token::TAB << operator[](index).rawText(); } dimensionedScalar ds("temp", xDims, 0.0); xDims.reset(j0(ds).dimensions()); operator[](index)[i].assignOpDimsFunction ( &Foam::equationReader::evalDimsJ0 ); }
inline JLBasis::Index JLBasis::first_wavelet(const int j) const { assert(j >= j0()); return JLIndex(j, 1, 0, 1); }
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; }
inline JLBasis::Index JLBasis::last_wavelet(const int j) const { assert(j >= j0()); return JLIndex(j, 1, 1, 1<<j); }
inline JLBasis::Index JLBasis::last_generator(const int j) const { assert(j >= j0()); return JLIndex(j, 0, 1, 1<<j); }
double Date::getYearDaysNum( double myY ) { Julian j1(date2Julian( myY+1., 1., 1., 0.) ); Julian j0(date2Julian( myY, 1., 1., 0.) ); return static_cast<double>( j1.jdn - j0.jdn ) ; }
double y0(double x) { double z,s,c,ss,cc,u,v; int32_t hx,ix,lx; EXTRACT_WORDS(hx, lx, x); ix = 0x7fffffff & hx; /* Y0(NaN) is NaN, y0(-inf) is Nan, y0(inf) is 0 */ if (ix >= 0x7ff00000) return 1.0/(x+x*x); if ((ix|lx) == 0) return -1.0/0.0; if (hx < 0) return 0.0/0.0; if (ix >= 0x40000000) { /* |x| >= 2.0 */ /* y0(x) = sqrt(2/(pi*x))*(p0(x)*sin(x0)+q0(x)*cos(x0)) * where x0 = x-pi/4 * Better formula: * cos(x0) = cos(x)cos(pi/4)+sin(x)sin(pi/4) * = 1/sqrt(2) * (sin(x) + cos(x)) * sin(x0) = sin(x)cos(3pi/4)-cos(x)sin(3pi/4) * = 1/sqrt(2) * (sin(x) - cos(x)) * To avoid cancellation, use * sin(x) +- cos(x) = -cos(2x)/(sin(x) -+ cos(x)) * to compute the worse one. */ s = sin(x); c = cos(x); ss = s-c; cc = s+c; /* * j0(x) = 1/sqrt(pi) * (P(0,x)*cc - Q(0,x)*ss) / sqrt(x) * y0(x) = 1/sqrt(pi) * (P(0,x)*ss + Q(0,x)*cc) / sqrt(x) */ if (ix < 0x7fe00000) { /* make sure x+x does not overflow */ z = -cos(x+x); if (s*c < 0.0) cc = z/ss; else ss = z/cc; } if (ix > 0x48000000) z = (invsqrtpi*ss)/sqrt(x); else { u = pzero(x); v = qzero(x); z = invsqrtpi*(u*ss+v*cc)/sqrt(x); } return z; } if (ix <= 0x3e400000) { /* x < 2**-27 */ return u00 + tpi*log(x); } z = x*x; u = u00+z*(u01+z*(u02+z*(u03+z*(u04+z*(u05+z*u06))))); v = 1.0+z*(v01+z*(v02+z*(v03+z*v04))); return u/v + tpi*(j0(x)*log(x)); }
void main() { double x, y, z; x = j0( 2.4 ); y = y1( 1.58 ); z = jn( 3, 2.4 ); printf( "j0(2.4) = %f, y1(1.58) = %f\n", x, y ); printf( "jn(3,2.4) = %f\n", z ); }
double Date::getDayOfTheYear(double y, double mo, double d, double h, double mi, double s) { double deciH = h + mi/60. + s/3600. ; Julian j0(date2Julian( y, 1., 1., 0.) ); Julian j1(date2Julian( y, mo, d, deciH) ); // the 1st of Jan, etc.! return ( static_cast<double>( j1.jdn - j0.jdn ) + 1. ) ; }
int main() { float y; int i; for (i = 0; i< 20; i++) { y = j0(z[i]); printf("%.9e\n", y); } exit(0); }
complex<double> CUniformDisk::GetVis(pair<double,double> & uv) { double radius = MasToRad(mRadius); // Calculate the visibility and return double baseline = sqrt(uv.first * uv.first + uv.second * uv.second); double phi = -2 * PI * (mAlpha * uv.first + mDelta * uv.second); double bess = PI * radius * baseline; complex<double> phase(cos(phi), sin(phi)); double V = 2 * j0(bess)/bess; return V * phase; }
double y0 (double x) { if (x < 0.0) return (dzero/dzero); /* IEEE machines: invalid operation */ if (x < 8.0) return yzero(x) + TWO_ON_PI * j0(x) * log(x); else return (sqrt (TWO_ON_PI/x) * (pzero(x) * sin (x - PI_ON_FOUR) + (8.0/x) * qzero(x) * cos(x - PI_ON_FOUR))); }
void Foam::equationReader::evalScalarFieldJ0 ( const equationReader * eqnReader, const label index, const label i, const label storageOffset, label& storeIndex, scalarField& x, const scalarField& source ) const { j0(x, x); }
void TensorProductBasis<BASIS0,BASIS1>::apply_Tjinv(const int j, const V& x, V& y) const { // T_j^{-1}=diag(G_{j0},I)*...*diag(G_{j-1},I)*G_j V z(x); apply_Gj(j, x, y); for (int k = j-1; k >= j0(); k--) { z.swap(y); apply_Gj(k, z, y); for (int i = Deltasize(k+1); i < Deltasize(j+1); i++) y[i] = z[i]; } }
template < class AA0 > static inline AA0 branch1(const AA0 & a0) { typedef typename meta::scalar_of<AA0>::type sAA0; AA0 z = sqr(a0); AA0 p2 = (z-single_constant<AA0, 0x3edd4b3a> ())* horner< NT2_HORNER_COEFF_T(sAA0, 5, (0x33cb0920, 0xb71ded71, 0x3a0c1a3e, 0xbc81c8f4, 0x3e2edb4f ) ) > (z); return p2+single_constant<AA0, 0x3f22f983>()*log(a0)*j0(a0); }
double y0(double arg) { double argsq, n, d; int i; errno = 0; if(arg <= 0) { errno = EDOM; return(-HUGE_VAL); } if(arg > 8) { asympt(arg); n = arg - pio4; return sqrt(tpi/arg)*(pzero*sin(n) + qzero*cos(n)); } argsq = arg*arg; for(n=0,d=0,i=8;i>=0;i--) { n = n*argsq + p4[i]; d = d*argsq + q4[i]; } return n/d + tpi*j0(arg)*log(arg); }
double Date::getMonthDaysNum( double myMon, double myY ) { if( currCalendarEnum == EQUAL_MONTHS ) return 30. ; int mon = static_cast<int>( myMon ); double t = regularMonthDays[mon-1] ; bool is = currCalendarEnum == GREGORIAN || currCalendarEnum == PROLEPTIC_GREGORIAN ; if( mon == 2 && is ) { Julian j1(date2Julian( myY, myMon +1., 1., 0.) ); Julian j0(date2Julian( myY, myMon , 1., 0.) ); long double tld= j1.jdn - j0.jdn ; tld += (j1.time -j0.time) ; t = static_cast<double>( static_cast<int>(tld+0.5) ); } return t ; }
double jv(double n, double x) { double k, q, t, y, an; int i, sign, nint; nint = 0; /* Flag for integer n */ sign = 1; /* Flag for sign inversion */ an = fabs(n); y = floor(an); if (y == an) { nint = 1; i = an - 16384.0 * floor(an / 16384.0); if (n < 0.0) { if (i & 1) sign = -sign; n = an; } if (x < 0.0) { if (i & 1) sign = -sign; x = -x; } if (n == 0.0) return (j0(x)); if (n == 1.0) return (sign * j1(x)); } if ((x < 0.0) && (y != an)) { mtherr("Jv", DOMAIN); y = NPY_NAN; goto done; } if (x == 0 && n < 0 && !nint) { mtherr("Jv", OVERFLOW); return NPY_INFINITY / gamma(n + 1); } y = fabs(x); if (y * y < fabs(n + 1) * MACHEP) { return pow(0.5 * x, n) / gamma(n + 1); } k = 3.6 * sqrt(y); t = 3.6 * sqrt(an); if ((y < t) && (an > 21.0)) return (sign * jvs(n, x)); if ((an < k) && (y > 21.0)) return (sign * hankel(n, x)); if (an < 500.0) { /* Note: if x is too large, the continued fraction will fail; but then the * Hankel expansion can be used. */ if (nint != 0) { k = 0.0; q = recur(&n, x, &k, 1); if (k == 0.0) { y = j0(x) / q; goto done; } if (k == 1.0) { y = j1(x) / q; goto done; } } if (an > 2.0 * y) goto rlarger; if ((n >= 0.0) && (n < 20.0) && (y > 6.0) && (y < 20.0)) { /* Recur backwards from a larger value of n */ rlarger: k = n; y = y + an + 1.0; if (y < 30.0) y = 30.0; y = n + floor(y - n); q = recur(&y, x, &k, 0); y = jvs(y, x) * q; goto done; } if (k <= 30.0) { k = 2.0; } else if (k < 90.0) { k = (3 * k) / 4; } if (an > (k + 3.0)) { if (n < 0.0) k = -k; q = n - floor(n); k = floor(k) + q; if (n > 0.0) q = recur(&n, x, &k, 1); else { t = k; k = n; q = recur(&t, x, &k, 1); k = t; } if (q == 0.0) { underf: y = 0.0; goto done; } } else { k = n; q = 1.0; } /* boundary between convergence of * power series and Hankel expansion */ y = fabs(k); if (y < 26.0) t = (0.0083 * y + 0.09) * y + 12.9; else t = 0.9 * y; if (x > t) y = hankel(k, x); else y = jvs(k, x); #if CEPHES_DEBUG printf("y = %.16e, recur q = %.16e\n", y, q); #endif if (n > 0.0) y /= q; else y *= q; } else { /* For large n, use the uniform expansion or the transitional expansion. * But if x is of the order of n**2, these may blow up, whereas the * Hankel expansion will then work. */ if (n < 0.0) { mtherr("Jv", TLOSS); y = NPY_NAN; goto done; } t = x / n; t /= n; if (t > 0.3) y = hankel(n, x); else y = jnx(n, x); } done: return (sign * y); }
double operator()(double k) const { return k*std::exp(-std::pow(k, 5./3.))*j0(k*_r); }
double besj0_ (const real *x) { return j0 (*x); }
double dbesj0_ (const double *x) { return j0 (*x); }
void test_extract() { int counts = 0; tbb::flow::tuple<int,int> dont_care; tbb::flow::graph g; typedef tbb::flow::source_node<int> snode_type; tbb::flow::source_node<int> s0(g, source_body<int>(counts), /*is_active*/false ); tbb::flow::join_node< tbb::flow::tuple<int,int>, tbb::flow::reserving > j0(g); tbb::flow::join_node< tbb::flow::tuple<int,int>, tbb::flow::reserving > j1(g); tbb::flow::join_node< tbb::flow::tuple<int,int>, tbb::flow::reserving > j2(g); tbb::flow::queue_node<int> q0(g); tbb::flow::queue_node<tbb::flow::tuple<int,int> > q1(g); tbb::flow::make_edge(s0, tbb::flow::get<0>(j0.input_ports())); /* s0 ----+ */ /* | j0 */ /* + */ ASSERT(!counts, "source_node activated too soon"); s0.activate(); g.wait_for_all(); // should produce one value, buffer it. ASSERT(counts == 1, "source_node did not react to activation"); g.reset(tbb::flow::rf_reset_bodies); counts = 0; s0.extract(); /* s0 + */ /* | j0 */ /* + */ s0.activate(); g.wait_for_all(); // no successors, so the body will not execute ASSERT(counts == 0, "source_node shouldn't forward (no successors)"); s0.extract(tbb::flow::rf_reset_bodies); tbb::flow::make_edge(s0, tbb::flow::get<0>(j0.input_ports())); tbb::flow::make_edge(s0, tbb::flow::get<0>(j1.input_ports())); tbb::flow::make_edge(s0, tbb::flow::get<0>(j2.input_ports())); /* /+ */ /* / | j0 */ /* / + */ /* / */ /* / /--+ */ /* s0-/ | j1 */ /* \ + */ /* \ */ /* \--+ */ /* | j2 */ /* + */ // do all joins appear in successor list? std::vector<tbb::flow::receiver<int>*> jv1; jv1.push_back(&(tbb::flow::get<0>(j0.input_ports()))); jv1.push_back(&(tbb::flow::get<0>(j1.input_ports()))); jv1.push_back(&(tbb::flow::get<0>(j2.input_ports()))); tbb::flow::source_node<int>::successor_vector_type sv; s0.copy_successors(sv); ASSERT(lists_match(sv, jv1), "mismatch in successor list"); tbb::flow::make_edge(q0, tbb::flow::get<1>(j2.input_ports())); tbb::flow::make_edge(j2, q1); s0.activate(); /* /+ */ /* / | j0 */ /* / + */ /* / */ /* / /--+ */ /* s0-/ | j1 */ /* \ + */ /* \ */ /* \--+ */ /* | j2----q1 */ /* q0-----+ */ q0.try_put(1); g.wait_for_all(); ASSERT(q1.try_get(dont_care), "join did not emit result"); j2.extract(); tbb::flow::make_edge(q0, tbb::flow::get<1>(j2.input_ports())); tbb::flow::make_edge(j2, q1); /* /+ */ /* / | j0 */ /* / + */ /* / */ /* / /--+ */ /* s0-/ | j1 */ /* + */ /* */ /* + */ /* | j2----q1 */ /* q0-----+ */ jv1.clear(); jv1.push_back(&(tbb::flow::get<0>(j0.input_ports()))); jv1.push_back(&(tbb::flow::get<0>(j1.input_ports()))); s0.copy_successors(sv); ASSERT(lists_match(sv, jv1), "mismatch in successor list"); q0.try_put(1); g.wait_for_all(); ASSERT(!q1.try_get(dont_care), "extract of successor did not remove pred link"); s0.extract(); /* + */ /* | j0 */ /* + */ /* */ /* + */ /* s0 | j1 */ /* + */ /* */ /* + */ /* | j2----q1 */ /* q0-----+ */ ASSERT(s0.successor_count() == 0, "successor list not cleared"); s0.copy_successors(sv); ASSERT(sv.size() == 0, "non-empty successor list"); tbb::flow::make_edge(s0, tbb::flow::get<0>(j2.input_ports())); /* + */ /* | j0 */ /* + */ /* */ /* + */ /* s0 | j1 */ /* \ + */ /* \ */ /* \--+ */ /* | j2----q1 */ /* q0-----+ */ jv1.clear(); jv1.push_back(&(tbb::flow::get<0>(j2.input_ports()))); s0.copy_successors(sv); ASSERT(lists_match(sv, jv1), "mismatch in successor list"); q0.try_put(1); g.wait_for_all(); ASSERT(!q1.try_get(dont_care), "extract of successor did not remove pred link"); }
double eval(stack * stk, stack1 * no) { stack1 nos = NULL; double x, y, z; char ch; ldiv_t ldivt; while (!empty(*stk)) { *stk = pop(*stk, &ch); if (ch == 'N') { *no = pop1(*no, &x); nos = push1(nos, x); } else if (ch == (char)0xD8) { } else { nos = pop1(nos, &y); if ((ch >= (char)0xA2 && ch <= (char)0xCA) && ch != (char)0xAA && ch != (char)0xCB && ch != (char)0xB9) x = 0; else nos = pop1(nos, &x); switch (ch) { case '+': z = add(x, y); break; case '-': z = dif(x, y); break; case '*': z = mul(x, y); break; case '/': if (y == 0.0) { eqp_errno = 6; return (0); } z = divide(x, y); break; case '^': z = pow(x, y); break; case '%': z = mod(x, y); break; /* The inline comments give the equivalent * gnuplot function */ case (char)0xA2: /* abs(x) */ z = fabs(y); break; case (char)0xA3: /* acos(x) */ if (y > 1 || y < -1) { /* eqp_errno = 9 ; return(0); */ } z = acos(y); break; case (char)0xA4: /* acosh(x) */ z = acosh(y); break; case (char)0xA6: /* asin(x) */ if (y > 1 || y < -1) { /* eqp_errno = 10 ; return(0); */ } z = asin(y); break; case (char)0xA7: /* asinh(x) */ z = asinh(y); break; case (char)0xA8: /* atan(x) */ z = atan(y); break; case (char)0xA9: /* atanh(x) */ if (y > 1 || y < -1) { eqp_errno = 11; return (0); } z = atanh(y); break; case (char)0xAA: /* atan2(y,x) */ z = atan2(x, y); break; case (char)0xAB: /* besj0(x) */ z = j0(y); break; case (char)0xAC: /* besj1(x) */ z = j1(y); break; case (char)0xAD: /* besy0(x) */ if (y <= 0) { eqp_errno = 8; return (0); } z = y0(y); break; case (char)0xAE: /* besy1(x) */ if (y <= 0) { eqp_errno = 18; return (0); } z = y1(y); break; case (char)0xAF: /* ceil(x) */ z = ceil(y); break; case (char)0xB1: /* cos(x) */ z = cos(y); break; case (char)0xB2: /* cosh(x) */ z = cosh(y); break; case (char)0xCB: /* div(num,denom) */ ldivt = ldiv((int) x, (int) y); z = (double) ldivt.quot; break; case (char)0xB3: /* erf(x) */ z = erf(y); break; case (char)0xB4: /* erfc(x) */ z = erfc(y); break; case (char)0xB5: /* exp(x) */ z = exp(y); break; case (char)0xB6: /* floor(x) */ z = floor(y); break; case (char)0xB7: /* gamma(x) */ z = exp(lgamma(y)); break; case (char)0xBB: /* int(x) */ z = rint(y); if (z > 0 && z > y) z--; if (z < 0 && z < y) z++; break; case (char)0xBC: /* inverf(x) */ if (y <= -1 || y >= 1) { eqp_errno = 19; return (0); } z = inverf(y); break; case (char)0xBD: /* invnorm(x) */ if (y <= 0 || y >= 1) { eqp_errno = 16; return (0); } z = sqrt(2) * inverf(2 * y - 1); break; case (char)0xBE: /* lgamma(x) */ z = lgamma(y); break; case (char)0xBF: /* log(x) */ if (y <= 0) { eqp_errno = 21; return (0); } z = log(y); break; case (char)0xC0: /* log10(x) */ z = log10(y); if (y <= 0) { eqp_errno = 20; return (0); } break; case (char)0xC1: /* norm(x) */ z = .5 * (1 + erf(y / sqrt(2))); break; case (char)0xC2: /* rand(x) */ z = ((double) rand()) / RAND_MAX; break; case (char)0xC4: /* sgn(x) */ if (y > 0) z = 1; else if (y < 0) z = -1; else z = 0; break; case (char)0xC5: /* sin(x) */ z = sin(y); break; case (char)0xC6: /* sinh(x) */ z = sinh(y); break; case (char)0xC7: /* sqrt(x) */ z = sqrt(y); break; case (char)0xC8: /* tan(x) */ z = tan(y); break; case (char)0xC9: /* tanh(x) */ z = tanh(y); break; } nos = push1(nos, z); } } nos = pop1(nos, &z); #ifdef DEBUG printf("\n%lf", z); #endif return (z); }
double G77_dbesj0_0 (const double *x) { return j0 (*x); }
float G77_besj0_0 (const real * x) { return (float) j0 ((double) *x); }