TSIL_COMPLEX TSIL_Tx0y (TSIL_REAL X, TSIL_REAL Y, TSIL_COMPLEX S,
TSIL_REAL QQ)
{
TSIL_COMPLEX sqDeltaSXY, tp, tm, log1mtp, log1mtm;
TSIL_REAL lnbarX, lnbarY;
if (X < TSIL_TOL) {
TSIL_Warn("TSIL_Tx0y", "T(x,0,y) is undefined for x = 0.");
return TSIL_Infinity;
}
if (TSIL_CABS(S) < TSIL_TOL) return -TSIL_I2p(X, 0.0L, Y, QQ);
if (Y < TSIL_TOL) return TSIL_Tx00(X, S, QQ);
S = TSIL_AddIeps(S);
sqDeltaSXY = TSIL_CSQRT(X*X + Y*Y + S*S - 2.0L*X*Y - 2.0L*X*S - 2.0L*Y*S);
lnbarX = TSIL_LOG(X/QQ);
lnbarY = TSIL_LOG(Y/QQ);
tp = (Y - X + S + sqDeltaSXY)/(2.0L * Y);
tm = (Y - X + S - sqDeltaSXY)/(2.0L * Y);
log1mtp = TSIL_CLOG(1.0L - tp);
log1mtm = TSIL_CLOG(1.0L - tm);
return (-TSIL_Dilog (tp) - TSIL_Dilog (tm) + (1.0L - Y/S)*log1mtp*log1mtm
+ sqDeltaSXY * (log1mtp - log1mtm) / (2.0L * S)
+ lnbarX*lnbarY - 0.5L*(lnbarY + 1.0L)*(lnbarY + 1.0L)
+ (3.0L*S + Y - X) *(lnbarY-lnbarX)/(2.0L * S));
}
TSIL_COMPLEX TSIL_TrilogCLZseries(TSIL_COMPLEX z)
{
TSIL_COMPLEX logz, logzsquared, logztothek, term;
TSIL_COMPLEX first6terms, remainingterms, result;
TSIL_REAL accuracygoal;
int j;
logz = TSIL_CLOG(z);
logzsquared = logz*logz;
logztothek = logzsquared*logzsquared*logzsquared;
first6terms = logztothek/86400.0L;
first6terms += -logzsquared*logzsquared/288.0L;
first6terms += -logzsquared*logz/12.0L;
first6terms += (0.75L - 0.5L*TSIL_CLOG(-logz))*logzsquared;
first6terms += cZeta3 + cZeta2*logz;
accuracygoal = TSIL_TOL* TSIL_CABS (first6terms);
remainingterms = 0.0L;
for (j=0; j< 25; j++)
{
logztothek = logztothek*logzsquared;
term = CLZcoeffs_trilog[j]*logztothek;
remainingterms += term;
if (TSIL_CABS (term) < accuracygoal)
break;
if (j == 24)
TSIL_Warn("TSIL_TrilogCLZseries", "trilog CLZ series converging too slowly.");
}
result = remainingterms + first6terms;
return result;
}
TSIL_COMPLEX TSIL_TrilogregionA (TSIL_COMPLEX z)
{
TSIL_COMPLEX result;
TSIL_COMPLEX log1minusz = TSIL_CLOG (1.0L - z);
TSIL_COMPLEX logminusz = TSIL_CLOG (-z);
result = -TSIL_Trilogunitdisk(1.0L/(1.0L - z)) - TSIL_Trilogunitdisk (z/(z - 1.0L))
+ log1minusz*(log1minusz*log1minusz/3.0L -
0.5L*logminusz*log1minusz - cZeta2) + cZeta3;
return result;
}
TSIL_COMPLEX TSIL_Trilogoutofunitdisk (TSIL_COMPLEX z)
{
TSIL_COMPLEX result;
TSIL_COMPLEX logminusz = TSIL_CLOG(-z);
if (TSIL_CREAL(z) > 1.0L && TSIL_CIMAG((complex double) z) == 0.0)
logminusz = I * PI_longdouble + TSIL_CLOG(TSIL_CREAL (z));
result = TSIL_Trilogunitdisk (1.0L/z) -
logminusz*(cZeta2 + logminusz*logminusz/6.0L);
return result;
}
TSIL_COMPLEX TSIL_Trilogunitdisk (TSIL_COMPLEX z)
{
TSIL_COMPLEX result;
TSIL_REAL rez = TSIL_CREAL (z);
TSIL_REAL absz = TSIL_CABS (z);
TSIL_REAL absimz = TSIL_FABS (TSIL_CIMAG (z));
if (TSIL_CABS(z - 1.0L) < 2.0L * TSIL_TOL)
result = cZeta3;
else if (TSIL_CABS(z) < 2.0L * TSIL_TOL)
result = 0.0L;
else if (TSIL_CABS(TSIL_CLOG(z)) < trilog_CLZseries_radius)
result = TSIL_TrilogCLZseries (z);
else if (absz <= trilog_powerseries_radius)
result = TSIL_Trilogseries (z);
else if (rez <= 0.0L)
result = TSIL_TrilogregionA (z);
else if (rez <= absimz)
result = TSIL_TrilogregionB (z);
else {
TSIL_Warn("TSIL_Trilogunitdisk", "trilog function yielding undefined result.");
result = TSIL_Infinity;
}
return result;
}
TSIL_COMPLEX TSIL_Trilogseries (TSIL_COMPLEX z)
{
TSIL_REAL absz = TSIL_CABS (z);
TSIL_REAL logepsilon = TSIL_LOG (TSIL_TOL);
TSIL_REAL mlogabsz;
TSIL_COMPLEX sum = z;
TSIL_COMPLEX ztothek;
TSIL_COMPLEX term;
TSIL_COMPLEX kcubed;
int k, kmax;
mlogabsz = -TSIL_CLOG (absz);
/*
The following kmax is hopefully designed to give accuracy to within
e^logepsilon, with some safety margin built in. Not completely
tested, but it seems good enough for government work anyway.
*/
kmax = 5 + (int) (( 6.0 -logepsilon -3.0 * log(-logepsilon)
+ 3.0 * log (mlogabsz)) / mlogabsz);
for (k = kmax; k > 1; k--)
{
ztothek = TSIL_CPOW (z, k);
kcubed = k*k*k;
term = ztothek/kcubed;
sum += term;
}
return sum;
}
TSIL_COMPLEX TSIL_B00 (TSIL_COMPLEX S, TSIL_REAL QQ)
{
if (TSIL_CABS (S) < TSIL_TOL) {
TSIL_Warn("TSIL_B00", "B(0,0) is undefined when s=0.");
return TSIL_Infinity;
}
S = TSIL_AddIeps(S);
return (2.0L - TSIL_CLOG(-S/QQ));
}
TSIL_COMPLEX TSIL_B0x (TSIL_REAL X, TSIL_COMPLEX S, TSIL_REAL QQ)
{
if (TSIL_FABS (X) < TSIL_TOL)
return TSIL_B00(S,QQ);
if (TSIL_CABS (S) < TSIL_TOL)
return (1.0L - TSIL_LOG (X/QQ));
if (TSIL_CABS (1.0L - S/X) < 10.0L*TSIL_TOL)
return 2.0L - TSIL_LOG(X/QQ);
S = TSIL_AddIeps(S);
return 2.0L + ((X - S)*TSIL_CLOG((X - S)/QQ) - X*TSIL_LOG(X/QQ))/S;
}
TSIL_COMPLEX TSIL_Beps0x (TSIL_REAL x, TSIL_COMPLEX s, TSIL_REAL qq)
{
TSIL_COMPLEX sqrtx, lnbarx, log1msox, lnbarms;
if (TSIL_CABS(s) < TSIL_TOL) return TSIL_BepsAtZero (0, x, qq);
if (x < TSIL_TOL) {
lnbarms = TSIL_CLOG(-TSIL_AddIeps(s)/qq);
return 4.0L - Zeta2/2.0L - 2.0L*lnbarms + lnbarms*lnbarms/2.0L;
}
sqrtx = TSIL_CSQRT(x);
lnbarx = TSIL_CLOG(x/qq);
if (TSIL_CABS(1 - s/x) < 10.0*TSIL_TOL)
return 4.0L + Zeta2/2.0L + lnbarx*(lnbarx - 4.0L)/2.0L;
log1msox = TSIL_CLOG(1.0L - TSIL_AddIeps(s)/x);
return 4.0L + Zeta2/2.0L - 2.0L*lnbarx + lnbarx*lnbarx/2.0L
+ (1.0L - x/s)*(lnbarx*log1msox - 2.0L*log1msox
+ log1msox*log1msox/2.0L -TSIL_Dilog(s/(s-x)));
}
TSIL_COMPLEX TSIL_BepsAtZero (TSIL_REAL x, TSIL_REAL y, TSIL_REAL qq)
{
TSIL_COMPLEX lnbarx, lnbary;
TSIL_REAL temp;
if (x < y) {temp = x; x = y; y = temp;}
if (x < TSIL_TOL) {
TSIL_Warn("TSIL_BepsAtZero", "Beps(0,0) is undefined at s = 0.");
return TSIL_Infinity;
}
lnbarx = TSIL_CLOG(x/qq);
if (y < TSIL_TOL) return 1.0L + Zeta2/2.0L - lnbarx + lnbarx*lnbarx/2.0L;
if (TSIL_FABS(x-y)/(x+y) < TSIL_TOL) return (Zeta2 + lnbarx*lnbarx)/2.0L;
lnbary = TSIL_CLOG(y/qq);
return 1.0L + Zeta2/2.0L + (x*lnbarx*(lnbarx/2.0L - 1.0L) -
y*lnbary*(lnbary/2.0L - 1.0L))/(x-y);
}
TSIL_COMPLEX TSIL_B (TSIL_REAL X, TSIL_REAL Y, TSIL_COMPLEX S, TSIL_REAL QQ)
{
TSIL_REAL temp;
TSIL_COMPLEX sqDeltaSXY, lnbarX, lnbarY;
if (TSIL_FABS (X) < TSIL_FABS (Y)) {temp = Y; Y = X; X = temp;}
if (TSIL_FABS (X) < TSIL_TOL)
return TSIL_B00(S,QQ);
if (TSIL_FABS (Y) < TSIL_TOL)
return TSIL_B0x(X,S,QQ);
if (TSIL_CABS (S) < TSIL_TOL) {
if (TSIL_FABS (1.0L - Y/X) > 0.0L)
return (1.0L + (Y*TSIL_LOG(Y/QQ) - X*TSIL_LOG(X/QQ))/(X-Y));
else
return (-TSIL_LOG (X/QQ));
}
S = TSIL_AddIeps(S);
sqDeltaSXY = TSIL_CSQRT(TSIL_Delta(S, X, Y));
lnbarX = TSIL_LOG (X/QQ);
lnbarY = TSIL_LOG (Y/QQ);
/* Following avoids roundoff error for very negative s. */
if ((TSIL_CREAL(S) < -10.0L*(X+Y)) && (TSIL_CIMAG(S) < TSIL_TOL)) {
return (2.0L - 0.5L * (lnbarX + lnbarY) +
(sqDeltaSXY * TSIL_CLOG(0.5L*(X + Y - S + sqDeltaSXY)/Y) +
0.5L * (Y - X - sqDeltaSXY) * (lnbarX - lnbarY))/S);
}
return (2.0L - 0.5L * (lnbarX + lnbarY) +
(-sqDeltaSXY * TSIL_CLOG(0.5L*(X + Y - S - sqDeltaSXY)/X) +
0.5L * (Y - X - sqDeltaSXY) * (lnbarX - lnbarY))/S);
}
TSIL_COMPLEX TSIL_Tx00 (TSIL_REAL X, TSIL_COMPLEX S, TSIL_REAL QQ)
{
TSIL_REAL lnbarX;
if (X < TSIL_TOL) {
TSIL_Warn("TSIL_Tx00", "T(x,0,0) is undefined for x = 0.");
return TSIL_Infinity;
}
if (TSIL_CABS(S) < TSIL_TOL) return -TSIL_I2p(X, 0.0L, 0.0L, QQ);
lnbarX = TSIL_LOG(X/QQ);
if (TSIL_CABS (1.0L - S/X) < 10.0L*TSIL_TOL)
return 2.0L*Zeta2 -0.5L -lnbarX + 0.5L*lnbarX*lnbarX;
S = TSIL_AddIeps(S);
return Zeta2 - 0.5L + (1.0L - X/S)*TSIL_CLOG(1.0L -S/X)
-lnbarX + 0.5L*lnbarX*lnbarX + TSIL_Dilog (S/X);
}
TSIL_COMPLEX TSIL_Beps (TSIL_REAL X, TSIL_REAL Y, TSIL_COMPLEX S, TSIL_REAL QQ)
{
TSIL_COMPLEX sqrtdeltasxy, t1, t2, t3, t4, logt1, logt2, logt3, logt4;
TSIL_COMPLEX log1mt1, log1mt2, sqrtx, sqrty, lnbarx, lnbary;
TSIL_REAL temp;
if (X < Y) {temp = X; X = Y; Y = temp;}
if (TSIL_CABS(S) < TSIL_TOL) return TSIL_BepsAtZero (X, Y, QQ);
if (Y < TSIL_TOL) return TSIL_Beps0x (X, S, QQ);
sqrtx = TSIL_CSQRT(X);
sqrty = TSIL_CSQRT(Y);
lnbarx = TSIL_CLOG(X/QQ);
lnbary = TSIL_CLOG(Y/QQ);
if (TSIL_CABS(S - (sqrtx + sqrty)*(sqrtx + sqrty))/(X+Y) < 10.0*TSIL_TOL)
return 4.0L + Zeta2/2.0L
+ (sqrtx*lnbarx*(lnbarx - 4.0L) +
sqrty*lnbary*(lnbary - 4.0L))/(2.0L*(sqrtx + sqrty));
if (TSIL_CABS(S - (sqrtx - sqrty)*(sqrtx - sqrty))/(X+Y) < 10.0*TSIL_TOL)
return 4.0L + Zeta2/2.0L
+ (sqrtx*lnbarx*(lnbarx - 4.0L) -
sqrty*lnbary*(lnbary - 4.0L))/(2.0L*(sqrtx - sqrty));
S = TSIL_AddIeps(S);
sqrtdeltasxy = TSIL_CSQRT(TSIL_Delta(S,X,Y));
t1 = ( S - X + Y + sqrtdeltasxy)/(2.0L*sqrtdeltasxy);
t2 = (-S - X + Y + sqrtdeltasxy)/(2.0L*sqrtdeltasxy);
t3 = (-S + X + Y + sqrtdeltasxy)/(2.0L*X);
t4 = (-S + X + Y - sqrtdeltasxy)/(2.0L*X);
/* printf("\ns = ");TSIL_cprintf(S);printf("\n"); */
/* printf("x = %Lf\n", X); */
/* printf("y = %Lf\n", Y); */
/* printf("sqrtdeltasxy = ");TSIL_cprintf(sqrtdeltasxy);printf("\n"); */
/* printf("\nt1 = ");TSIL_cprintf(t1);printf("\n"); */
/* printf("t2 = ");TSIL_cprintf(t2);printf("\n"); */
/* printf("t3 = ");TSIL_cprintf(t3);printf("\n"); */
/* printf("t4 = ");TSIL_cprintf(t4);printf("\n"); */
logt1 = TSIL_CLOG(t1);
logt2 = TSIL_CLOG(t2);
logt3 = TSIL_CLOG(t3);
logt4 = TSIL_CLOG(t4);
/* printf("\nlogt1 = ");TSIL_cprintf(logt1);printf("\n"); */
/* printf("logt2 = ");TSIL_cprintf(logt2);printf("\n"); */
/* printf("logt3 = ");TSIL_cprintf(logt3);printf("\n"); */
/* printf("logt4 = ");TSIL_cprintf(logt4);printf("\n"); */
log1mt1 = TSIL_CLOG(1.0L - t1);
log1mt2 = TSIL_CLOG(1.0L - t2);
return 4.0L + Zeta2/2.0L + (lnbarx*lnbarx + lnbary*lnbary)/4.0L
- lnbarx - lnbary + (sqrtdeltasxy*(TSIL_Dilog(t2) - TSIL_Dilog(t1)
+ (logt3 - logt4)*(1.0L - lnbarx/4.0L - lnbary/4.0L)
+ (log1mt1 + log1mt2)*(logt2 - logt1)/2.0L)
+ (X - Y)*(lnbary - lnbarx)*(1.0L - lnbarx/4.0L - lnbary/4.0L))/S;
}
void TSIL_CaseGeneric (TSIL_DATA *foo)
{
TSIL_COMPLEX sInit, sFinal, rInit, rFinal, imDisp;
TSIL_REAL sthresh;
TSIL_REAL s = foo->s;
TSIL_REAL qq = foo->qq;
TSIL_REAL threshMin = foo->threshMin;
TSIL_REAL smallestspecialpoint;
TSIL_REAL temp;
int i;
TSIL_Info("GENERIC CASE");
/* Decide how to initialize; is s=0 a threshold, or close to one? */
if (threshMin < TSIL_TOL) {
TSIL_Info("There is a threshold at s=0.");
sInit = I*SINIT;
TSIL_InitialValueThreshAt0 (foo, sInit);
}
else if (threshMin < THRESH_CUTOFF) {
TSIL_Info("There is a threshold close to, but not at, s=0.");
sInit = -SINIT;
TSIL_InitialValue (foo, sInit);
}
else {
sInit = 0.L + 0.L*I;
TSIL_InitialValue (foo, 0.0L + 0.0L*I);
}
/* Find the point nearest s=0 that could give problems: */
smallestspecialpoint = (foo->threshold)[0];
for (i=1; i<(foo->nThresh); i++) {
if ((foo->threshold)[i] < smallestspecialpoint)
smallestspecialpoint = (foo->threshold)[i];
}
for (i=0; i<(foo->nPthresh); i++) {
if ((foo->pseudoThreshold)[i] < smallestspecialpoint)
smallestspecialpoint = (foo->pseudoThreshold)[i];
}
if (s < (smallestspecialpoint - THRESH_CUTOFF)) {
/* Integrate along real s axis. */
sFinal = (TSIL_COMPLEX) 0.5L*s;
if (threshMin < THRESH_CUTOFF) {
/* The smallest threshold is either 0 or close to 0, so change
variables to r = lnbar(-s) for the first part of integration. */
rInit = TSIL_CLOG(-sInit/qq);
temp = -0.5L*s/qq;
if (temp > TSIL_TOL) rFinal = TSIL_CLOG(temp);
else if (temp < -TSIL_TOL) rFinal = TSIL_CLOG(-temp) - I*PI;
else rFinal = TSIL_CLOG(0.001L*TSIL_EPSILON) - I*0.5L*PI;
TSIL_Integrate (foo, rInit, rFinal, TSIL_MaxSteps(foo,rFinal-rInit), 3, 0.0L);
}
else
TSIL_Integrate (foo, sInit, sFinal, TSIL_MaxSteps(foo,sFinal-sInit), 0, 0.0L);
sInit = sFinal;
sFinal = (TSIL_COMPLEX) s;
TSIL_Integrate (foo, sInit, sFinal, TSIL_MaxSteps(foo, sFinal-sInit), 1, 0.0L);
/* Set status value */
foo->status = REAXIS;
}
else {
/* Integrate in complex s plane. */
/* No reason to go too far off the real axis if s is small. */
if (s < IM_DISPL/10.0)
imDisp = 10.0L * s * I;
else
imDisp = IM_DISPL * I;
sFinal = imDisp;
if (threshMin < THRESH_CUTOFF) {
TSIL_Info("Using ln(-s/qq) as independent variable for first leg of contour.");
rInit = TSIL_CLOG(-sInit/qq);
rFinal = TSIL_CLOG(-sFinal/qq);
TSIL_Integrate (foo, rInit, rFinal, TSIL_MaxSteps(foo,rFinal-rInit), 3, 0.0L);
}
else TSIL_Integrate (foo, sInit, sFinal, TSIL_MaxSteps(foo,sFinal - sInit), 0, 0.0L);
sInit = sFinal;
sFinal = s + imDisp;
TSIL_Integrate (foo, sInit, sFinal, TSIL_MaxSteps(foo,sFinal - sInit), 0, 0.0L);
sInit = sFinal;
sFinal = s;
if (TSIL_NearThreshold (foo, &sthresh, THRESH_CUTOFF) == YES) {
if (TSIL_FABS(sthresh) < TSIL_TOL) {
rInit = TSIL_CLOG(-sInit/qq);
rFinal = TSIL_CLOG(-sFinal/qq - I*TSIL_EPSILON);
TSIL_Integrate (foo, rInit, rFinal, TSIL_MaxSteps(foo,rFinal-rInit), 3, 0.0L);
}
else {
TSIL_Info("Using near-threshold stepper for final leg of contour.");
rInit = TSIL_CLOG(1.L - sInit/sthresh);
temp = 1.L - s/sthresh;
if (temp > TSIL_TOL) rFinal = TSIL_CLOG(temp);
else if (temp < -TSIL_TOL) rFinal = TSIL_CLOG(-temp) - I*PI;
else rFinal = TSIL_CLOG(0.001L*TSIL_EPSILON) - I*0.5L*PI;
TSIL_Integrate (foo, rInit, rFinal, TSIL_MaxSteps(foo,rFinal - rInit), 2, sthresh);
}
}
else
TSIL_Integrate (foo, sInit, sFinal, TSIL_MaxSteps(foo,sFinal - sInit), 1, 0.0L);
/* Set status value */
foo->status = CONTOUR;
}
/* Check whether we had a double pole case in any of the U's and fix
it, if necessary: */
if ((foo->x < TSIL_TOL) || (foo->y < TSIL_TOL) ||
(foo->z < TSIL_TOL) || (foo->u < TSIL_TOL))
TSIL_CorrectUs (foo);
/* Finally, convert s*M to M */
foo->M.value /= s;
return;
}
void TSIL_InitialValueThreshAt0 (TSIL_DATA *foo, TSIL_COMPLEX sinit)
{
TSIL_REAL x, y, z, u, v, qq;
TSIL_COMPLEX rinit;
/* For convenience */
x = foo->x;
y = foo->y;
z = foo->z;
u = foo->u;
v = foo->v;
qq = foo->qq;
rinit = TSIL_CLOG(-sinit/qq);
if (x + z < TSIL_TOL) {
if (foo->whichFns == STUM) {
foo->B[xz].value = 2.0L - rinit;
foo->B[xz].deriv = -1.0L/sinit;
}
}
else {
if (foo->whichFns == STUM) {
foo->B[xz].value = TSIL_BAtZero (x, z, qq);
foo->B[xz].deriv = 0.0L;
foo->U[zxyv].value = TSIL_UAtZero (z, x, y, v, qq);
foo->U[zxyv].deriv = 0.0L;
}
if (foo->whichFns != ST) {
foo->U[xzuv].value = TSIL_UAtZero (x, z, u, v, qq);
foo->U[xzuv].deriv = 0.0L;
}
}
if (foo->whichFns == STUM) {
if (y + u < TSIL_TOL) {
foo->B[yu].value = 2.0L - rinit;
foo->B[yu].deriv = -1.0L/sinit;
}
else {
foo->B[yu].value = TSIL_BAtZero (y, u, qq);
foo->B[yu].deriv = 0.0L;
foo->U[yuzv].value = TSIL_UAtZero (y, u, z, v, qq);
foo->U[yuzv].deriv = 0.0L;
foo->U[uyxv].value = TSIL_UAtZero (u, y, x, v, qq);
foo->U[uyxv].deriv = 0.0L;
}
}
/* This is needed in all cases: */
if (x + u + v < TSIL_TOL) {
foo->S[uxv].value = sinit*(1.625L - 0.5L*rinit);
foo->S[uxv].deriv = 1.125L - 0.5L*rinit;
}
else {
foo->S[uxv].value = TSIL_SAtZero (u, x, v, qq);
foo->S[uxv].deriv = TSIL_SprimeAtZero (u, x, v, qq);
foo->T[uxv].value = TSIL_TAtZero (u, x, v, qq);
foo->T[xuv].value = TSIL_TAtZero (x, u, v, qq);
foo->T[vxu].value = TSIL_TAtZero (v, x, u, qq);
}
if (foo->whichFns == STUM) {
if (y + z + v < TSIL_TOL) {
foo->S[vyz].value = sinit*(1.625L - 0.5L*rinit);
foo->S[vyz].deriv = 1.125L - 0.5L*rinit;
}
else {
foo->S[vyz].value = TSIL_SAtZero (v, y, z, qq);
foo->S[vyz].deriv = TSIL_SprimeAtZero (v, y, z, qq);
foo->T[vyz].value = TSIL_TAtZero (v, y, z, qq);
foo->T[yzv].value = TSIL_TAtZero (y, z, v, qq);
foo->T[zyv].value = TSIL_TAtZero (z, y, v, qq);
}
}
/* Next initialize M. */
if (foo->whichFns == STUM)
foo->M.value = 0.0L;
/* Derivatives of T and M always initialized to zero when s=0 is a
threshold, because dF/dr = s dF/ds -> 0 for very small s. */
foo->T[uxv].deriv = 0.0L;
foo->T[xuv].deriv = 0.0L;
foo->T[vxu].deriv = 0.0L;
if (foo->whichFns == STUM) {
foo->T[vyz].deriv = 0.0L;
foo->T[yzv].deriv = 0.0L;
foo->T[zyv].deriv = 0.0L;
foo->M.deriv = 0.0L;
}
/* We can set the T's to zero and disable their running if the first
arg is zero, since they are TSIL_Infinity in this case. (Note
that the T derivatives are all taken care of above.) Some of
these are accomplished above so this is a bit redundant,
but... */
if (foo->whichFns == STUM) {
if (v < TSIL_TOL)
foo->T[vyz].value = foo->T[vxu].value = 0.0 + 0.0*I;
if (y < TSIL_TOL)
foo->T[yzv].value = 0.0 + 0.0*I;
if (z < TSIL_TOL)
foo->T[zyv].value = 0.0 + 0.0*I;
}
/* The rest are always needed: */
if (u < TSIL_TOL)
foo->T[uxv].value = 0.0 + 0.0*I;
if (x < TSIL_TOL)
foo->T[xuv].value = 0.0 + 0.0*I;
/* Similarly for the U's if the second arg is zero; here they are
not infinite, but the running gives garbage and they need
correction at the end of the calculation anyway: */
if (foo->whichFns == STUM) {
if (x < TSIL_TOL) {
foo->U[zxyv].value =
foo->U[zxyv].deriv = 0.0 + 0.0*I;
}
if (y < TSIL_TOL) {
foo->U[uyxv].value =
foo->U[uyxv].deriv = 0.0 + 0.0*I;
}
if (u < TSIL_TOL) {
foo->U[yuzv].value =
foo->U[yuzv].deriv = 0.0 + 0.0*I;
}
}
if (foo->whichFns != ST) {
if (z < TSIL_TOL) {
foo->U[xzuv].value =
foo->U[xzuv].deriv = 0.0 + 0.0*I;
}
}
return;
}
