TSIL_COMPLEX pi21tilde_sdL (int i, TSIL_REAL s)
{
int k;
TSIL_COMPLEX result = 0.0L;
TSIL_DATA bar;
TSIL_RESULT gaak;
TSIL_COMPLEX gFF,gff;
TSIL_COMPLEX gSSFF,gSSff;
if (arePandNsdLSet == NO) SetPandNsdL ();
TSIL_SetParameters (&bar,0.0L,0.0L,m2_gluino,m2_gluino,0.0L,Q2);
TSIL_Evaluate (&bar, s);
TSIL_CopyResult (&bar, &gaak);
G_FF (&gaak, &gFF, &gff);
TSIL_SetParameters (&bar,0.0L,m2_gluino,m2_sdL[i],0.1L,m2_gluino,Q2);
TSIL_Evaluate (&bar, s);
TSIL_CopyResult (&bar, &gaak);
Gtilde_SSFF (&gaak, &gSSFF, &gSSff);
TSIL_SetParameters (&bar,0.0L,m2_gluino,m2_sdL[i],0.01L,m2_gluino,Q2);
TSIL_Evaluate (&bar, s);
TSIL_CopyResult (&bar, &gaak);
Gtilde_SSFF (&gaak, &gSSFF, &gSSff);
TSIL_SetParameters (&bar,0.0L,m2_gluino,m2_sdL[i],0.0L,m2_gluino,Q2);
TSIL_Evaluate (&bar, s);
TSIL_CopyResult (&bar, &gaak);
Gtilde_SSFF (&gaak, &gSSFF, &gSSff);
/* NOTE m_q = 0 for q != top */
result += Cq*CG*(gFF + gSSFF
/* - NsdL[i][i]*0.0L*m_gluino*(gff + gSSff) */
);
TSIL_SetParameters (&bar,0.0L,0.0L,m2_sdL[i],m2_gluino,0.0L,Q2);
TSIL_Evaluate (&bar, s);
TSIL_CopyResult (&bar, &gaak);
Gtilde_SSFF (&gaak, &gSSFF, &gSSff);
result += (2.0L*Cq - CG)*Cq*(gSSFF
/* - NsdL[i][i]*0.0L*m_gluino*gSSff */
);
for (k=0; k<2; k++)
result += Cq * Cq * PsdL[i][k] * PsdL[k][i] *
(G_S(m2_sdL[k],Q2) + Gtilde_SSS(m2_sdL[i],m2_sdL[k],Q2));
result *= g3*g3*g3*g3;
return result;
}
TSIL_COMPLEX SUMO_GetFunction (TSIL_DATA *foo, const char *which,
int interp)
{
TSIL_REAL arg1, arg2, delta, snew;
TSIL_COMPLEX Vplus, Vminus;
TSIL_DATA gaak;
/* This is cut and pasted from tsil_names.h: */
const char *vname[4][2] = {{"Vzxyv","Vzxvy"},
{"Vuyxv","Vuyvx"},
{"Vxzuv","Vxzvu"},
{"Vyuzv","Vyuvz"}};
/* If no interp requested, or not a V function, just return the
usual thing: */
if (interp == NO || strncmp (which, "V", 1) != 0)
return TSIL_GetFunction (foo, which);
/* Check for a threshold case: */
if ( !strcmp(which, vname[0][0]) || !strcmp(which, vname[0][1])
|| !strcmp(which, vname[2][0]) || !strcmp(which, vname[2][1])) {
arg1 = foo->z; arg2 = foo->x;
}
else if ( !strcmp(which, vname[1][0]) || !strcmp(which, vname[1][1])
|| !strcmp(which, vname[3][0]) || !strcmp(which, vname[3][1])) {
arg1 = foo->u; arg2 = foo->y;
}
else {
printf("This can never happen!!!\n"); exit(234);
}
delta = foo->s/TSIL_POW(TSIL_SQRT(arg1)+TSIL_SQRT(arg2),2) - 1.0L;
if (TSIL_FABS(delta) > THRESH_TOL)
return TSIL_GetFunction (foo, which);
/* If we get here we interpolate: */
TSIL_SetParameters (&gaak, foo->x, foo->y, foo->z, foo->u, foo->v, foo->qq);
snew = (1.0L + THRESH_TOL)*(foo->s);
TSIL_Evaluate (&gaak, snew);
Vplus = TSIL_GetFunction (&gaak, which);
snew = (1.0L - THRESH_TOL)*(foo->s);
TSIL_Evaluate (&gaak, snew);
Vminus = TSIL_GetFunction (&gaak, which);
return 0.5L*(1.0L + delta/THRESH_TOL)*Vplus +
0.5L*(1.0L - delta/THRESH_TOL)*Vminus;
}
int main (int argc, char *argv[])
{
TSIL_DATA result; /* Top-level TSIL data object */
TSIL_REAL qq; /* Ensures correct basic type; see also TSIL_COMPLEX */
TSIL_REAL x, g, lambda;
TSIL_COMPLEX pi1, pi1prime, pi2, s1, s2;
TSIL_REAL factor = 1.0L/(16.0L*PI*PI);
/* If incorrect number of args, print message on stderr and exit: */
if (argc != 5)
TSIL_Error("main", "Expected 4 arguments: m^2, g, lambda, and Q^2", 1);
/* Note cast to appropriate floating-point type for safety */
x = (TSIL_REAL) strtold(argv[1], (char **) NULL);
g = (TSIL_REAL) strtold(argv[2], (char **) NULL);
lambda = (TSIL_REAL) strtold(argv[3], (char **) NULL);
qq = (TSIL_REAL) strtold(argv[4], (char **) NULL);
/* All loop integrals have a common squared-mass argument x: */
TSIL_SetParameters (&result, x, x, x, x, x, qq);
/* For the pole mass calculation, evaluate two-loop integrals at s = x: */
TSIL_Evaluate (&result, x);
/* Assemble one- and two-loop mass squared results: */
pi1 = 0.5L*lambda*TSIL_A(x,qq) - 0.5L*g*g*TSIL_B(x,x,x,qq);
pi1prime = -0.5L*g*g*TSIL_dBds(x, x, x, qq);
pi2 = - 0.5L*g*g*g*g*TSIL_GetFunction(&result, "M")
- 0.5L*g*g*g*g*TSIL_GetFunction(&result, "Vzxyv")
+ g*g*g*TSIL_GetFunction(&result, "Uzxyv")
- (1.0L/6.0L)*lambda*lambda*TSIL_GetFunction(&result, "Svyz")
+ 0.25L*lambda*g*g*TSIL_POW(TSIL_GetFunction(&result, "Bxz"), 2)
+ 0.25L*lambda*lambda*TSIL_A(x,qq)*(TSIL_A(x,qq)/x + 1.0L)
- 0.5L*lambda*g*g*TSIL_A(x,qq)*TSIL_Bp(x, x, x, qq)
- 0.25L*lambda*g*g*TSIL_I2p(x,x,x,qq);
s1 = x + factor*pi1;
s2 = x + factor*pi1 + factor*factor*(pi2 + pi1*pi1prime);
printf("Tree-level squared mass: %lf\n", (double) x);
printf("One-loop pole squared mass: %lf\n", (double) s1);
printf("Two-loop pole squared mass: %lf\n", (double) s2);
return 0;
}
TSIL_COMPLEX pi20_sdL (int i, int j, TSIL_REAL s)
{
int k,m,n,r,t;
TSIL_COMPLEX result = 0.0L;
TSIL_COMPLEX term = 0.0L;
TSIL_DATA bar;
TSIL_RESULT gaak,gaak2;
TSIL_COMPLEX vFFFFS, vFffFS, vfFfFS, vfFFfS, vFFffS, vffffS;
TSIL_COMPLEX mFFFFS, mFFffS, mFfFfS, mFffFS, mffffS;
TSIL_COMPLEX sSSS;
if (arePandNsdLSet == NO) SetPandNsdL ();
/* 0502168 eq. (4.8), term by term: */
for (k=0; k<2; k++)
for (m=0; m<2; m++)
for (n=0; n<2; n++)
term += PsdL[i][k] * PsdL[k][m] * PsdL[m][n] * PsdL[n][j] *
X_SSS (m2_sdL[k],m2_sdL[n],m2_sdL[m],Q2);
result += 0.25L*term;
term = 0.0L;
for (k=0; k<2; k++)
term += PsdL[i][k] * PsdL[k][j] *
W_SSFF (m2_sdL[k],m2_sdL[k],0.0L,m2_gluino,Q2);
/* NOTE m_q = 0 for q != top */
/* for (k=0; k<2; k++) */
/* for (m=0; m<2; m++) { */
/* term += -PsdL[i][k] * NsdL[k][m] * PsdL[m][j] * 0.0L * m_gluino * */
/* W_SSff (m2_sdL[k],m2_sdL[m],0.0L,m2_gluino,Q2); */
/* } */
result += 0.5*term;
/* Now term will be the second part, multiplied by (4Cq^2 - 2CG Cq): */
term = 0.0L;
for (k=0; k<2; k++) {
TSIL_SetParameters (&bar,m2_gluino,0.0L,0.0L,m2_gluino,m2_sdL[k],Q2);
TSIL_Evaluate (&bar, s);
TSIL_CopyResult (&bar, &gaak);
V_FFFFS (&gaak, &gaak,
&vFFFFS, &vFffFS, &vfFfFS, &vfFFfS, &vFFffS, &vffffS);
result += (LsdL[i] * LsdLc[j] * LsdL[k] * LsdLc[k] +
RsdL[i] * RsdLc[j] * RsdL[k] * RsdLc[k]) * vFFFFS
+ (LsdL[i] * RsdLc[j] * RsdL[k] * LsdLc[k] +
RsdL[i] * LsdLc[j] * LsdL[k] * RsdLc[k]) * m2_gluino * vfFFfS
/* + (LsdL[i] * LsdLc[j] * RsdL[k] * RsdLc[k] + */
/* RsdL[i] * RsdLc[j] * LsdL[k] * LsdLc[k]) * 0.0L * vFffFS */
/* - NsdL[i][j] * 0.0L * m_gluino * vfFfFS */
/* + (LsdL[i] * RsdLc[j] * LsdL[k] * RsdLc[k] + */
/* RsdL[i] * LsdLc[j] * RsdL[k] * LsdLc[k]) * 0.0L * m2_gluino * vffffS */
;
/* if (i==j) */
/* result += -NsdL[k][k] * 0.0L * m_gluino * vFFffS; */
TSIL_PermuteResult (&gaak, XYandZU, &gaak2);
M_FFFFS (&gaak2, &mFFFFS, &mFFffS, &mFfFfS, &mFffFS, &mffffS);
term += (LsdL[i] * RsdLc[j] * RsdL[k] * LsdLc[k] +
RsdL[i] * LsdLc[j] * LsdL[k] * RsdLc[k]) * mFFFFS
/* - NsdL[i][j] * 0.0L * m_gluino * mFFffS */
+ (LsdL[i] * LsdLc[j] * LsdL[k] * LsdLc[k]
+ RsdL[i] * RsdLc[j] * RsdL[k] * RsdLc[k]) * m2_gluino * mFffFS
/* + (LsdL[i] * RsdLc[j] * LsdL[k] * RsdLc[k] + */
/* RsdL[i] * LsdLc[j] * RsdL[k] * LsdLc[k]) * 0.0L * m2_gluino * mffffS */
;
/* if (i==j) */
/* term += -NsdL[k][k] * 0.0L * m_gluino * mFfFfS; */
/* M_FFFFS (&gaak, &mFFFFS, &mFFffS, &mFfFfS, &mFffFS, &mffffS); */
/* term += (LsdL[i] * LsdLc[j] * RsdL[k] * RsdLc[k] + */
/* RsdL[i] * RsdLc[j] * LsdL[k] * LsdLc[k]) * 0.0L * mFffFS; */
for (m=0; m<2; m++)
for (n=0; n<2; n++) {
TSIL_SetParametersST (&bar,m2_sdL[k],m2_sdL[m],m2_sdL[n],Q2);
TSIL_Evaluate (&bar, s);
/* For clarity (we just need this one function): */
sSSS = -bar.S[uxv].value;
term += 0.25L * PsdL[i][k] * PsdL[k][m] * PsdL[m][n] * PsdL[n][j] * sSSS;
}
}
result *= 4.0L*Cq*Cq;
result += term*(4.0L*Cq*Cq - 2.0L*CG*Cq);
/* Next bit is last three lines of eq. (4.8). These involve summing
over all 12 quark/squark mass eigenstates. */
term = 0.0L;
/* stop */
for (r=0; r<2; r++) {
TSIL_SetParameters (&bar,0.0L,m2_gluino,m2_gluino,m2_top,m2_stop[r],Q2);
TSIL_Evaluate (&bar, s);
TSIL_CopyResult (&bar, &gaak);
V_FFFFS (&gaak, &gaak, &vFFFFS, &vFffFS, &vfFfFS, &vfFFfS, &vFFffS, &vffffS);
term += -2.0L * NsdL[i][j] * m_top * m_gluino * vfFfFS
+ NsdL[i][j] * NsdL[r][r] * 0.0L * m_top * (vfFFfS + m2_gluino*vffffS);
if (i == j)
term += vFFFFS + m2_gluino*vFffFS - 2.0L*NsdL[r][r]*m_top*m_gluino*vFFffS;
for (k=0; k<2; k++)
for (t=0; t<2; t++) {
TSIL_SetParametersST (&bar,m2_sdL[k],m2_stop[r],m2_stop[t],Q2);
TSIL_Evaluate (&bar, s);
/* For clarity (just need this one function): */
sSSS = -bar.S[uxv].value;
term += 0.25L * PsdL[i][k] * PsdL[k][j] * PsdL[r][t] * PsdL[t][r] * sSSS;
}
}
/* sbot */
for (r=0; r<2; r++) {
TSIL_SetParameters (&bar,0.0L,m2_gluino,m2_gluino,m2_bot,m2_sbot[r],Q2);
TSIL_Evaluate (&bar, s);
TSIL_CopyResult (&bar, &gaak);
V_FFFFS (&gaak, &gaak,
&vFFFFS, &vFffFS, &vfFfFS, &vfFFfS, &vFFffS, &vffffS);
/* Take mbot ~ 0 */
/* term += -2.0L*NsdL[i][j]*m_bot*m_gluino*vfFfFS */
/* + NsdL[i][j]*NsdL[r][r]*0.0L*m_bot*(vfFFfS + m2_gluino*vffffS) */
;
if (i == j)
term += vFFFFS + m2_gluino*vFffFS
/* - 2.0L*NsdL[r][r]*m_bot*m_gluino*vFFffS */
;
for (k=0; k<2; k++)
for (t=0; t<2; t++) {
TSIL_SetParametersST (&bar,m2_sdL[k],m2_sbot[r],m2_sbot[t],Q2);
TSIL_Evaluate (&bar, s);
/* For clarity (just need this one function): */
sSSS = -bar.S[uxv].value;
term += 0.25L * PsdL[i][k] * PsdL[k][j] * PsdL[r][t] * PsdL[t][r] * sSSS;
}
}
/* sdL */
for (r=0; r<2; r++) {
TSIL_SetParameters (&bar,0.0L,m2_gluino,m2_gluino,0.0L,m2_sdL[r],Q2);
TSIL_Evaluate (&bar, s);
TSIL_CopyResult (&bar, &gaak);
V_FFFFS (&gaak, &gaak,
&vFFFFS, &vFffFS, &vfFfFS, &vfFFfS, &vFFffS, &vffffS);
/* Tese terms are all zero since the fermion mass is zero */
/* term = -2.0L*NsdL[i][j]* 0.0L *m_gluino*vfFfFS */
/* + NsdL[i][j]*NsdL[r][r]*0.0L* 0.0L *(vfFFfS + m2_gluino*vffffS); */
if (i == j)
term += vFFFFS + m2_gluino*vFffFS
/* - 2.0L*NsdL[r][r]* 0.0L *m_gluino*vFFffS */
;
for (k=0; k<2; k++)
for (t=0; t<2; t++) {
TSIL_SetParametersST (&bar,m2_sdL[k],m2_sdL[r],m2_sdL[t],Q2);
TSIL_Evaluate (&bar, s);
/* For clarity (just need this one function): */
sSSS = -bar.S[uxv].value;
term += 0.25L * PsdL[i][k] * PsdL[k][j] * PsdL[r][t] * PsdL[t][r] * sSSS;
}
}
/* suR */
for (r=0; r<2; r++) {
TSIL_SetParameters (&bar,0.0L,m2_gluino,m2_gluino,0.0L,m2_suR[r],Q2);
TSIL_Evaluate (&bar, s);
TSIL_CopyResult (&bar, &gaak);
V_FFFFS (&gaak, &gaak,
&vFFFFS, &vFffFS, &vfFfFS, &vfFFfS, &vFFffS, &vffffS);
/* Tese terms are all zero since the fermion mass is zero */
/* term = -2.0L*NsdL[i][j]* 0.0L *m_gluino*vfFfFS */
/* + NsdL[i][j]*NsdL[r][r]*0.0L* 0.0L *(vfFFfS + m2_gluino*vffffS); */
if (i == j)
term += vFFFFS + m2_gluino*vFffFS
/* - 2.0L*NsdL[r][r]* 0.0L *m_gluino*vFFffS */
;
for (k=0; k<2; k++)
for (t=0; t<2; t++) {
TSIL_SetParametersST (&bar,m2_sdL[k],m2_suR[r],m2_suR[t],Q2);
TSIL_Evaluate (&bar, s);
/* For clarity (just need this one function): */
sSSS = -bar.S[uxv].value;
term += 0.25L * PsdL[i][k] * PsdL[k][j] * PsdL[r][t] * PsdL[t][r] * sSSS;
}
}
/* sdL */
for (r=0; r<2; r++) {
TSIL_SetParameters (&bar,0.0L,m2_gluino,m2_gluino,0.0L,m2_sdL[r],Q2);
TSIL_Evaluate (&bar, s);
TSIL_CopyResult (&bar, &gaak);
V_FFFFS (&gaak, &gaak,
&vFFFFS, &vFffFS, &vfFfFS, &vfFFfS, &vFFffS, &vffffS);
/* Tese terms are all zero since the fermion mass is zero */
/* term = -2.0L*NsdL[i][j]* 0.0L *m_gluino*vfFfFS */
/* + NsdL[i][j]*NsdL[r][r]*0.0L* 0.0L *(vfFFfS + m2_gluino*vffffS); */
if (i == j)
term += vFFFFS + m2_gluino*vFffFS
/* - 2.0L*NsdL[r][r]* 0.0L *m_gluino*vFFffS */
;
for (k=0; k<2; k++)
for (t=0; t<2; t++) {
TSIL_SetParametersST (&bar,m2_sdL[k],m2_sdL[r],m2_sdL[t],Q2);
TSIL_Evaluate (&bar, s);
/* For clarity (just need this one function): */
sSSS = -bar.S[uxv].value;
term += 0.25L * PsdL[i][k] * PsdL[k][j] * PsdL[r][t] * PsdL[t][r] * sSSS;
}
}
/* sdR */
for (r=0; r<2; r++) {
TSIL_SetParameters (&bar,0.0L,m2_gluino,m2_gluino,0.0L,m2_sdR[r],Q2);
TSIL_Evaluate (&bar, s);
TSIL_CopyResult (&bar, &gaak);
V_FFFFS (&gaak, &gaak,
&vFFFFS, &vFffFS, &vfFfFS, &vfFFfS, &vFFffS, &vffffS);
/* Tese terms are all zero since the fermion mass is zero */
/* term = -2.0L*NsdL[i][j]* 0.0L *m_gluino*vfFfFS */
/* + NsdL[i][j]*NsdL[r][r]*0.0L* 0.0L *(vfFFfS + m2_gluino*vffffS); */
if (i == j)
term += vFFFFS + m2_gluino*vFffFS
/* - 2.0L*NsdL[r][r]* 0.0L *m_gluino*vFFffS */
;
for (k=0; k<2; k++)
for (t=0; t<2; t++) {
TSIL_SetParametersST (&bar,m2_sdL[k],m2_sdR[r],m2_sdR[t],Q2);
TSIL_Evaluate (&bar, s);
/* For clarity (just need this one function): */
sSSS = -bar.S[uxv].value;
term += 0.25L * PsdL[i][k] * PsdL[k][j] * PsdL[r][t] * PsdL[t][r] * sSSS;
}
}
result += 4.0L*Cq*Iq*term;
result *= g3*g3*g3*g3;
/* End of eq. (4.8) */
return result;
}
int main (int argc, char *argv[])
{
#include "tsil_names.h"
TSIL_REAL x, y, z, u, v, s, qq;
TSIL_COMPLEX val;
TSIL_DATA result;
int i, j, k, p, foo, tally[3], nwarn, nfail, npass;
char c;
TSIL_COMPLEX Mvalue, Uvalue[4], Vvalue[4], Svalue[2], Tvalue[6], Bvalue[2];
TSIL_COMPLEX Tbarvalue[6], UUvalue[4][3], VVvalue[4][3], SSvalue[2][3];
TSIL_COMPLEX TTvalue[6][3];
TSIL_REAL xx, yy, zz, uu, vv;
/* gcc complains unless the following are initialized; this may be a
gcc bug? Fortunately, it doesn't hurt to initialize them. */
int permU = 0;
int permS = 0;
int permT11 = 0;
int permT12 = 0;
int permT21 = 0;
int permT22 = 0;
int permT31 = 0;
int permT32 = 0;
if (argc == 1)
TSIL_Error ("main", "Must supply test data filename(s)...", 2);
nwarn = nfail = npass = 0;
printf("===== TSIL TEST SUITE =====\n");
#if defined (TSIL_TEST_STU)
printf("** Testing STU Evaluation only!\n");
#elif defined (TSIL_TEST_ST)
printf("** Testing ST Evaluation only!\n");
#endif
/* We don't need no stinkin' TSIL_Warnings here. */
fclose (stderr);
/* Loop over input files */
for (i = 1; i < argc; i++)
{
if ((fp = fopen(argv[i], "r")) == NULL) {
TSIL_Warn ("Test program", "Invalid file name");
continue;
}
printf ("\nTest %d: ", i);
printf ("%s\n", argv[i]);
fflush (stdout);
/* Skip any lines starting with '(' (comments): */
while ((c = fgetc (fp)) == '(')
SkipLine (fp);
/* Put back the last character after we find a non-comment line */
ungetc ((int) c, fp);
/* Read in parameters */
xx = x = GetReal ();
yy = y = GetReal ();
zz = z = GetReal ();
uu = u = GetReal ();
vv = v = GetReal ();
s = GetReal ();
qq = GetReal ();
/* Calculate everything... */
#if defined(TSIL_TEST_STU)
TSIL_SetParametersSTU (&result, x, z, u, v, qq);
#elif defined(TSIL_TEST_ST)
TSIL_SetParametersST (&result, x, u, v, qq);
#else
TSIL_SetParameters (&result, x, y, z, u, v, qq);
#endif
TSIL_Evaluate (&result, s);
for (j = 0; j < 3; j++)
tally[j] = 0;
/* ...and test results: */
#if defined(TSIL_TEST_STU)
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
/* U */
for (j = 2; j < 4; j+=2)
{
val = GetComplex ();
Uvalue[j] = result.U[j].value;
TSIL_Compare (uname[j], val, Uvalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
CheckConsistent (Uvalue[2], TSIL_GetFunction(&result,"Uxzuv"));
val = GetComplex ();
val = GetComplex ();
/* T */
for (j = 1; j < 6; j+=2)
{
val = GetComplex ();
Tvalue[j] = result.T[j].value;
TSIL_Compare (tname[j], val, Tvalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
val = GetComplex ();
}
CheckConsistent (Tvalue[1], TSIL_GetFunction(&result,"Tuxv"));
CheckConsistent (Tvalue[3], TSIL_GetFunction(&result,"Txuv"));
CheckConsistent (Tvalue[5], TSIL_GetFunction(&result,"Tvxu"));
/* S */
for (j = 1; j < 2; j+=2)
{
val = GetComplex ();
Svalue[j] = result.S[j].value;
TSIL_Compare (sname[j], val, Svalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
CheckConsistent (Svalue[1], TSIL_GetFunction(&result,"Suxv"));
/* B */
for (j = 0; j < 2; j+=2)
{
val = GetComplex ();
Bvalue[j] = result.B[j].value;
TSIL_Compare (bname[j], val, Bvalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
CheckConsistent (Bvalue[0], TSIL_GetFunction(&result,"Bxz"));
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
/* V */
for (j = 2; j < 4; j+=2)
{
val = GetComplex ();
Vvalue[j] = result.V[j].value;
TSIL_Compare (vname[j], val, Vvalue[j], TSIL_PASS_V, TSIL_WARN_V, &foo);
tally[foo]++;
}
CheckConsistent (Vvalue[2], TSIL_GetFunction(&result,"Vxzuv"));
val = GetComplex ();
/* Tbar */
val = GetComplex ();
for (j = 1; j < 6; j+=2)
{
val = GetComplex ();
Tbarvalue[j] = result.Tbar[j].value;
TSIL_Compare (tbarname[j], val, Tbarvalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
val = GetComplex ();
}
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
/* UU */
for (j = 2; j < 4; j+=2)
{
for (k = 0; k < 3; k++)
{
val = GetComplex ();
UUvalue[j][k] = result.U[j].bold[k];
TSIL_Compare (uuname[j][k], val, UUvalue[j][k], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
}
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
/* VV */
for (j = 2; j < 4; j+=2)
{
for (k = 0; k < 3; k++)
{
val = GetComplex ();
VVvalue[j][k] = result.V[j].bold[k];
TSIL_Compare (vvname[j][k], val, VVvalue[j][k], TSIL_PASS_V, TSIL_WARN_V, &foo);
tally[foo]++;
}
}
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
/* TT */
for (j = 1; j < 6; j+=2)
{
for (k = 0; k < 3; k++)
{
val = GetComplex ();
TTvalue[j][k] = result.T[j].bold[k];
TSIL_Compare (ttname[j][k], val, TTvalue[j][k], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
}
/* SS */
for (j = 1; j < 2; j+=2)
{
for (k = 0; k < 3; k++)
{
val = GetComplex ();
SSvalue[j][k] = result.S[j].bold[k];
TSIL_Compare (ssname[j][k], val, SSvalue[j][k], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
}
#elif defined(TSIL_TEST_ST)
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
/* U */
for (j = 2; j < 4; j+=2)
{
val = GetComplex ();
}
val = GetComplex ();
val = GetComplex ();
/* T */
for (j = 1; j < 6; j+=2)
{
val = GetComplex ();
Tvalue[j] = result.T[j].value;
TSIL_Compare (tname[j], val, Tvalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
val = GetComplex ();
}
CheckConsistent (Tvalue[1], TSIL_GetFunction(&result,"Tuxv"));
CheckConsistent (Tvalue[3], TSIL_GetFunction(&result,"Txuv"));
CheckConsistent (Tvalue[5], TSIL_GetFunction(&result,"Tvxu"));
/* S */
for (j = 1; j < 2; j+=2)
{
val = GetComplex ();
Svalue[j] = result.S[j].value;
TSIL_Compare (sname[j], val, Svalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
CheckConsistent (Svalue[1], TSIL_GetFunction(&result,"Suxv"));
/* B */
for (j = 0; j < 2; j+=2)
{
val = GetComplex ();
}
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
/* V */
for (j = 2; j < 4; j+=2)
{
val = GetComplex ();
}
val = GetComplex ();
/* Tbar */
val = GetComplex ();
for (j = 1; j < 6; j+=2)
{
val = GetComplex ();
Tbarvalue[j] = result.Tbar[j].value;
TSIL_Compare (tbarname[j], val, Tbarvalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
val = GetComplex ();
}
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
/* UU */
for (j = 2; j < 4; j+=2)
{
for (k = 0; k < 3; k++)
{
val = GetComplex ();
}
}
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
/* VV */
for (j = 2; j < 4; j+=2)
{
for (k = 0; k < 3; k++)
{
val = GetComplex ();
}
}
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
/* TT */
for (j = 1; j < 6; j+=2)
{
for (k = 0; k < 3; k++)
{
val = GetComplex ();
TTvalue[j][k] = result.T[j].bold[k];
TSIL_Compare (ttname[j][k], val, TTvalue[j][k], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
val = GetComplex ();
val = GetComplex ();
val = GetComplex ();
}
/* SS */
for (j = 1; j < 2; j+=2)
{
for (k = 0; k < 3; k++)
{
val = GetComplex ();
SSvalue[j][k] = result.S[j].bold[k];
TSIL_Compare (ssname[j][k], val, SSvalue[j][k], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
}
#else
/* M */
val = GetComplex ();
Mvalue = result.M.value;
CheckConsistent (Mvalue, TSIL_GetFunction(&result,"M"));
TSIL_Compare ("M", val, Mvalue, TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
/* U */
for (j = 0; j < 4; j++)
{
val = GetComplex ();
Uvalue[j] = result.U[j].value;
TSIL_Compare (uname[j], val, Uvalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
CheckConsistent (Uvalue[0], TSIL_GetFunction(&result,"Uzxyv"));
CheckConsistent (Uvalue[1], TSIL_GetFunction(&result,"Uuyxv"));
CheckConsistent (Uvalue[2], TSIL_GetFunction(&result,"Uxzuv"));
CheckConsistent (Uvalue[3], TSIL_GetFunction(&result,"Uyuzv"));
/* T */
for (j = 0; j < 6; j++)
{
val = GetComplex ();
Tvalue[j] = result.T[j].value;
TSIL_Compare (tname[j], val, Tvalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
CheckConsistent (Tvalue[0], TSIL_GetFunction(&result,"Tvyz"));
CheckConsistent (Tvalue[1], TSIL_GetFunction(&result,"Tuxv"));
CheckConsistent (Tvalue[2], TSIL_GetFunction(&result,"Tyzv"));
CheckConsistent (Tvalue[3], TSIL_GetFunction(&result,"Txuv"));
CheckConsistent (Tvalue[4], TSIL_GetFunction(&result,"Tzyv"));
CheckConsistent (Tvalue[5], TSIL_GetFunction(&result,"Tvxu"));
/* S */
for (j = 0; j < 2; j++)
{
val = GetComplex ();
Svalue[j] = result.S[j].value;
TSIL_Compare (sname[j], val, Svalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
CheckConsistent (Svalue[0], TSIL_GetFunction(&result,"Svyz"));
CheckConsistent (Svalue[1], TSIL_GetFunction(&result,"Suxv"));
/* B */
for (j = 0; j < 2; j++)
{
val = GetComplex ();
Bvalue[j] = result.B[j].value;
TSIL_Compare (bname[j], val, Bvalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
CheckConsistent (Bvalue[0], TSIL_GetFunction(&result,"Bxz"));
CheckConsistent (Bvalue[1], TSIL_GetFunction(&result,"Byu"));
/* V */
for (j = 0; j < 4; j++)
{
val = GetComplex ();
Vvalue[j] = result.V[j].value;
TSIL_Compare (vname[j], val, Vvalue[j], TSIL_PASS_V, TSIL_WARN_V, &foo);
tally[foo]++;
}
CheckConsistent (Vvalue[0], TSIL_GetFunction(&result,"Vzxyv"));
CheckConsistent (Vvalue[1], TSIL_GetFunction(&result,"Vuyxv"));
CheckConsistent (Vvalue[2], TSIL_GetFunction(&result,"Vxzuv"));
CheckConsistent (Vvalue[3], TSIL_GetFunction(&result,"Vyuzv"));
/* Tbar */
for (j = 0; j < 6; j++)
{
val = GetComplex ();
Tbarvalue[j] = result.Tbar[j].value;
TSIL_Compare (tbarname[j], val, Tbarvalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
/* UU */
for (j = 0; j < 4; j++)
{
for (k = 0; k < 3; k++)
{
val = GetComplex ();
UUvalue[j][k] = result.U[j].bold[k];
TSIL_Compare (uuname[j][k], val, UUvalue[j][k], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
}
/* VV */
for (j = 0; j < 4; j++)
{
for (k = 0; k < 3; k++)
{
val = GetComplex ();
VVvalue[j][k] = result.V[j].bold[k];
TSIL_Compare (vvname[j][k], val, VVvalue[j][k], TSIL_PASS_V, TSIL_WARN_V, &foo);
tally[foo]++;
}
}
/* TT */
for (j = 0; j < 6; j++)
{
for (k = 0; k < 3; k++)
{
val = GetComplex ();
TTvalue[j][k] = result.T[j].bold[k];
TSIL_Compare (ttname[j][k], val, TTvalue[j][k], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
}
/* SS */
for (j = 0; j < 2; j++)
{
for (k = 0; k < 3; k++)
{
val = GetComplex ();
SSvalue[j][k] = result.S[j].bold[k];
TSIL_Compare (ssname[j][k], val, SSvalue[j][k], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
}
#endif
if (tally[FAIL] > 0)
{
nfail++;
printf ("FAILED FOR INPUT PARAMETERS:\n");
printf ("x = %.6lf;\n", (double) x);
printf ("y = %.6lf;\n", (double) y);
printf ("z = %.6lf;\n", (double) z);
printf ("u = %.6lf;\n", (double) u);
printf ("v = %.6lf;\n", (double) v);
printf ("s = %.6lf;\n", (double) s);
printf ("qq = %.6lf;\n", (double) qq);
}
else if (tally[WARN] > 0)
{
printf ("PASS WITH WARNING\n");
nwarn++;
}
else
{
printf ("PASS\n");
npass++;
}
if (1 == Doperms)
{
for (p = 0; p < 4; p++)
{
for (j = 0; j < 3; j++)
tally[j] = 0;
x = xx;
y = yy;
z = zz;
u = uu;
v = vv;
if (1 == p)
{
swapR (&x, &y);
swapR (&z, &u);
}
if (2 == p)
{
swapR (&x, &z);
swapR (&y, &u);
}
if (3 == p)
{
swapR (&x, &u);
swapR (&y, &z);
}
/* Calculate everything... */
TSIL_SetParameters (&result, x, y, z, u, v, qq);
TSIL_Evaluate (&result, s);
Permuteresults (&result, p);
printf ("\nTest %d, permutation %d (", i, p);
printf ("%s", argv[i]);
printf ("): ");
/* ...and check that permuted results agree as they
should: */
/* M */
val = result.M.value;
TSIL_Compare ("M", val, Mvalue, TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
/* U */
for (j = 0; j < 4; j++)
{
val = result.U[j].value;
TSIL_Compare (uname[j], val, Uvalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
/* T */
for (j = 0; j < 6; j++)
{
val = result.T[j].value;
TSIL_Compare (tname[j], val, Tvalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
/* S */
for (j = 0; j < 2; j++)
{
val = result.S[j].value;
TSIL_Compare (sname[j], val, Svalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
/* B */
for (j = 0; j < 2; j++)
{
val = result.B[j].value;
TSIL_Compare (bname[j], val, Bvalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
/* V */
for (j = 0; j < 4; j++)
{
val = result.V[j].value;
TSIL_Compare (vname[j], val, Vvalue[j], TSIL_PASS_V, TSIL_WARN_V, &foo);
tally[foo]++;
}
/* Tbar */
for (j = 0; j < 6; j++)
{
val = result.Tbar[j].value;
TSIL_Compare (tbarname[j], val, Tbarvalue[j], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
/* UU */
for (j = 0; j < 4; j++)
{
for (k = 0; k < 3; k++)
{
val = result.U[j].bold[k];
TSIL_Compare (uuname[j][k], val, UUvalue[j][k], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
}
/* VV */
for (j = 0; j < 4; j++)
{
for (k = 0; k < 3; k++)
{
val = result.V[j].bold[k];
TSIL_Compare (vvname[j][k], val, VVvalue[j][k], TSIL_PASS_V, TSIL_WARN_V, &foo);
tally[foo]++;
}
}
/* TT */
for (j = 0; j < 6; j++)
{
for (k = 0; k < 3; k++)
{
val = result.T[j].bold[k];
TSIL_Compare (ttname[j][k], val, TTvalue[j][k], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
}
/* SS */
for (j = 0; j < 2; j++)
{
for (k = 0; k < 3; k++)
{
val = result.S[j].bold[k];
TSIL_Compare (ssname[j][k], val, SSvalue[j][k], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
}
if (tally[FAIL] > 0)
{
nfail++;
printf ("\nFAILED FOR INPUT PARAMETERS:\n");
printf ("x = %.3lf;\n", (double) x);
printf ("y = %.3lf;\n", (double) y);
printf ("z = %.3lf;\n", (double) z);
printf ("u = %.3lf;\n", (double) u);
printf ("v = %.3lf;\n", (double) v);
printf ("s = %.3lf;\n", (double) s);
printf ("qq = %.3lf;\n", (double) qq);
}
else if (tally[WARN] > 0)
{
nwarn++;
printf ("\nPASS WITH WARNING\n");
}
else
{
printf ("\nPASS\n");
npass++;
}
}
}
if (1 == Doextraperms)
{
for (p = 4; p < 8; p++)
{
x = xx;
y = yy;
z = zz;
u = uu;
v = vv;
if (p == 4)
{
swapR (&x, &v);
permU = 1;
permT11 = 1;
permT12 = 1;
permT21 = 3;
permT22 = 5;
permT31 = 5;
permT32 = 3;
permS = 1;
}
if (p == 5)
{
swapR (&y, &v);
permU = 0;
permT11 = 0;
permT12 = 2;
permT21 = 2;
permT22 = 0;
permT31 = 4;
permT32 = 4;
permS = 0;
}
if (p == 6)
{
swapR (&z, &v);
permU = 3;
permT11 = 0;
permT12 = 4;
permT21 = 4;
permT22 = 0;
permT31 = 2;
permT32 = 2;
permS = 0;
}
if (p == 7)
{
swapR (&u, &v);
permU = 2;
permT11 = 1;
permT12 = 5;
permT21 = 5;
permT22 = 1;
permT31 = 3;
permT32 = 3;
permS = 1;
}
for (j = 0; j < 3; j++)
tally[j] = 0;
/* Calculate everything... */
TSIL_SetParameters (&result, x, y, z, u, v, qq);
TSIL_Evaluate (&result, s);
printf ("\nTest %d, permutation %d (", i, p);
printf ("%s", argv[i]);
printf ("): ");
/* ...and check results: */
/* U */
for (j = 0; j < 4; j++)
{
val = Uvalue[j];
if (j == permU)
{
TSIL_Compare (uname[j], val, result.U[j].value, TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
}
/* T */
for (j = 0; j < 6; j++)
{
val = Tvalue[j];
if (j == permT11)
{
TSIL_Compare (tname[j], val, result.T[permT12].value,
TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
if (j == permT21)
{
TSIL_Compare (tname[j], val, result.T[permT22].value,
TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
if (j == permT31)
{
TSIL_Compare (tname[j], val, result.T[permT32].value,
TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
}
/* S */
for (j = 0; j < 2; j++)
{
val = Svalue[j];
if (j == permS)
{
TSIL_Compare (sname[j], val, result.S[j].value,
TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
}
/* V */
for (j = 0; j < 4; j++)
{
val = Vvalue[j];
if (j == permU)
{
TSIL_Compare (vname[j], val, result.V[j].value,
TSIL_PASS_V, TSIL_WARN_V, &foo);
tally[foo]++;
}
}
/* Tbar */
for (j = 0; j < 6; j++)
{
val = Tbarvalue[j];
if (j == permT11)
{
TSIL_Compare (tbarname[j], val, result.Tbar[permT12].value,
TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
if (j == permT21)
{
TSIL_Compare (tbarname[j], val, result.Tbar[permT22].value,
TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
if (j == permT31)
{
TSIL_Compare (tbarname[j], val, result.Tbar[permT32].value,
TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
}
/* UU */
for (j = 0; j < 4; j++)
{
for (k = 0; k < 3; k++)
{
val = UUvalue[j][k];
if (j == permU)
{
TSIL_Compare (uuname[j][k], val, result.U[j].bold[k],
TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
}
}
/* VV */
for (j = 0; j < 4; j++)
{
for (k = 0; k < 3; k++)
{
val = VVvalue[j][k];
if (j == permU)
{
TSIL_Compare (vvname[j][k], val, result.V[j].bold[k],
TSIL_PASS_V, TSIL_WARN_V, &foo);
tally[foo]++;
}
}
}
/* TT */
for (j = 0; j < 6; j++)
{
for (k = 0; k < 3; k++)
{
val = TTvalue[j][k];
if (j == permT11)
{
TSIL_Compare (ttname[j][k], val,
result.T[permT12].bold[k],
TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
if (j == permT21)
{
TSIL_Compare (ttname[j][k], val,
result.T[permT22].bold[k], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
if (j == permT31)
{
TSIL_Compare (ttname[j][k], val,
result.T[permT32].bold[k], TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
}
}
/* SS */
for (j = 0; j < 2; j++)
{
for (k = 0; k < 3; k++)
{
val = SSvalue[j][k];
if (j == permS)
{
TSIL_Compare (ssname[j][k], val, result.S[j].bold[k],
TSIL_PASS, TSIL_WARN, &foo);
tally[foo]++;
}
}
}
if (tally[FAIL] > 0)
{
nfail++;
printf ("\nFAILED FOR INPUT PARAMETERS:\n");
printf ("x = %.16lf;\n", (double) x);
printf ("y = %.16lf;\n", (double) y);
printf ("z = %.16lf;\n", (double) z);
printf ("u = %.16lf;\n", (double) u);
printf ("v = %.16lf;\n", (double) v);
printf ("s = %.16lf;\n", (double) s);
printf ("qq = %.16lf;\n", (double) qq);
}
else if (tally[WARN] > 0)
{
nwarn++;
printf ("\nPASS\n");
}
else
{
printf ("\nPASS\n");
npass++;
}
}
}
fclose (fp);
printf ("\n===== Done with input file ");
printf ("%s", argv[i]);
printf (" =====\n");
}
printf ("\n== FINAL RESULTS ==\n");
printf ("Total input files: %d\n", (argc - 1));
printf ("Total tests performed: %d\n",
(1 + Doperms * 3 + Doextraperms * 4) * (argc - 1));
printf ("Pass: %d\n", npass);
printf ("Warn: %d\n", nwarn);
printf ("Fail: %d\n", nfail);
return 0;
}
void tsilfevaluate_ (TSIL_REAL_F *x,
TSIL_REAL_F *y,
TSIL_REAL_F *z,
TSIL_REAL_F *u,
TSIL_REAL_F *v,
TSIL_REAL_F *qq,
TSIL_REAL_F *s)
{
/* Below is cut and pasted directly from tsil_names.h */
const char *uname[] = {"Uzxyv","Uuyxv","Uxzuv","Uyuzv"};
const char *tname[] = {"Tvyz", "Tuxv", "Tyzv", "Txuv", "Tzyv", "Tvxu"};
const char *sname[] = {"Svyz", "Suxv"};
const char *bname[] = {"Bxz", "Byu"};
const char *vname[] = {"Vzxyv","Vuyxv","Vxzuv","Vyuzv"};
const char *tbarname[] = {"TBARvyz", "TBARuxv", "TBARyzv",
"TBARxuv", "TBARzyv", "TBARvxu"};
TSIL_DATA res;
int i, j;
static int compiledSize = TSIL_REAL_SIZE_F;
if (rsize_.rsize != compiledSize)
TSIL_Warn ("tsilfevaluate", "Apparent type mismatch between Fortran and C!");
TSIL_SetParameters (&res,
(TSIL_REAL) (*x),
(TSIL_REAL) (*y),
(TSIL_REAL) (*z),
(TSIL_REAL) (*u),
(TSIL_REAL) (*v),
(TSIL_REAL) (*qq));
TSIL_Evaluate (&res, (TSIL_REAL) (*s));
/* Extract results */
results_.M = (TSIL_COMPLEX_F) TSIL_GetFunction (&res, "M");
/* Note non-standard indexing-by-pointer of UU, VV, TT, SS arrays
for compatibility with Fortran indexing convention. */
for (i=0; i<NUM_U_FUNCS; i++) {
results_.U[i] = (TSIL_COMPLEX_F) TSIL_GetFunction (&res, uname[i]);
results_.V[i] = (TSIL_COMPLEX_F) TSIL_GetFunction (&res, vname[i]);
for (j=0; j<3; j++) {
*(&(results_.UU[0][0]) + j * NUM_U_FUNCS + i) =
(TSIL_COMPLEX_F) TSIL_GetBoldFunction (&res, uname[i], j);
*(&(results_.VV[0][0]) + j * NUM_U_FUNCS + i) =
(TSIL_COMPLEX_F) TSIL_GetBoldFunction (&res, vname[i], j);
}
}
for (i=0; i<NUM_T_FUNCS; i++) {
results_.T[i] = (TSIL_COMPLEX_F) TSIL_GetFunction (&res, tname[i]);
results_.Tbar[i] = (TSIL_COMPLEX_F) TSIL_GetFunction (&res, tbarname[i]);
for (j=0; j<3; j++)
*(&(results_.TT[0][0]) + j * NUM_T_FUNCS + i) =
(TSIL_COMPLEX_F) TSIL_GetBoldFunction (&res, tname[i], j);
}
for (i=0; i<NUM_S_FUNCS; i++) {
results_.S[i] = (TSIL_COMPLEX_F) TSIL_GetFunction (&res, sname[i]);
for (j=0; j<3; j++)
*(&(results_.SS[0][0]) + j * NUM_S_FUNCS + i) =
(TSIL_COMPLEX_F) TSIL_GetBoldFunction (&res, sname[i], j);
}
for (i=0; i<NUM_B_FUNCS; i++)
results_.B[i] = (TSIL_COMPLEX_F) TSIL_GetFunction (&res, bname[i]);
return;
}