void p_accu(double *p_resh, double *p_resm, double *p_resl, double xh, double xm) {
double p_t_1_0h;
double p_t_2_0h;
double p_t_3_0h;
double p_t_4_0h;
double p_t_5_0h;
double p_t_6_0h;
double p_t_7_0h;
double p_t_8_0h;
double p_t_9_0h, p_t_9_0m;
double p_t_10_0h, p_t_10_0m;
double p_t_11_0h, p_t_11_0m;
double p_t_12_0h, p_t_12_0m;
double p_t_13_0h, p_t_13_0m;
double p_t_14_0h, p_t_14_0m;
double p_t_15_0h, p_t_15_0m;
double p_t_16_0h, p_t_16_0m, p_t_16_0l;
double p_t_17_0h, p_t_17_0m, p_t_17_0l;
double p_t_18_0h, p_t_18_0m, p_t_18_0l;
double p_t_19_0h, p_t_19_0m, p_t_19_0l;
double p_t_20_0h, p_t_20_0m, p_t_20_0l;
double p_t_21_0h, p_t_21_0m, p_t_21_0l;
p_t_1_0h = p_coeff_accu_12h;
p_t_2_0h = p_t_1_0h * xh;
p_t_3_0h = p_coeff_accu_11h + p_t_2_0h;
p_t_4_0h = p_t_3_0h * xh;
p_t_5_0h = p_coeff_accu_10h + p_t_4_0h;
p_t_6_0h = p_t_5_0h * xh;
p_t_7_0h = p_coeff_accu_9h + p_t_6_0h;
p_t_8_0h = p_t_7_0h * xh;
Add12(p_t_9_0h,p_t_9_0m,p_coeff_accu_8h,p_t_8_0h);
MulAdd22(&p_t_10_0h,&p_t_10_0m,p_coeff_accu_7h,p_coeff_accu_7m,xh,xm,p_t_9_0h,p_t_9_0m);
MulAdd22(&p_t_11_0h,&p_t_11_0m,p_coeff_accu_6h,p_coeff_accu_6m,xh,xm,p_t_10_0h,p_t_10_0m);
MulAdd22(&p_t_12_0h,&p_t_12_0m,p_coeff_accu_5h,p_coeff_accu_5m,xh,xm,p_t_11_0h,p_t_11_0m);
Mul22(&p_t_13_0h,&p_t_13_0m,p_t_12_0h,p_t_12_0m,xh,xm);
Add122(&p_t_14_0h,&p_t_14_0m,p_coeff_accu_4h,p_t_13_0h,p_t_13_0m);
Mul22(&p_t_15_0h,&p_t_15_0m,p_t_14_0h,p_t_14_0m,xh,xm);
Add23(&p_t_16_0h,&p_t_16_0m,&p_t_16_0l,p_coeff_accu_3h,p_coeff_accu_3m,p_t_15_0h,p_t_15_0m);
Mul233(&p_t_17_0h,&p_t_17_0m,&p_t_17_0l,xh,xm,p_t_16_0h,p_t_16_0m,p_t_16_0l);
Add133(&p_t_18_0h,&p_t_18_0m,&p_t_18_0l,p_coeff_accu_2h,p_t_17_0h,p_t_17_0m,p_t_17_0l);
Mul233(&p_t_19_0h,&p_t_19_0m,&p_t_19_0l,xh,xm,p_t_18_0h,p_t_18_0m,p_t_18_0l);
Add133(&p_t_20_0h,&p_t_20_0m,&p_t_20_0l,p_coeff_accu_1h,p_t_19_0h,p_t_19_0m,p_t_19_0l);
Mul233(&p_t_21_0h,&p_t_21_0m,&p_t_21_0l,xh,xm,p_t_20_0h,p_t_20_0m,p_t_20_0l);
Renormalize3(p_resh,p_resm,p_resl,p_t_21_0h,p_t_21_0m,p_t_21_0l);
}
void exp_td_accurate(double *polyTblh, double *polyTblm, double *polyTbll,
double rh, double rm, double rl,
double tbl1h, double tbl1m, double tbl1l,
double tbl2h, double tbl2m, double tbl2l) {
double highPoly, highPolyMulth, highPolyMultm, highPolyMultl;
double rhSquareh, rhSquarel, rhSquareHalfh, rhSquareHalfl;
double rhCubeh, rhCubem, rhCubel;
double t1h, t1l, t2h, t2l, t3h, t3l, t4h, t4l, t5, t6;
double lowPolyh, lowPolym, lowPolyl;
double ph, pm, pl, phnorm, pmnorm, rmlMultPh, rmlMultPl;
double qh, ql, fullPolyh, fullPolym, fullPolyl;
double polyWithTbl1h, polyWithTbl1m, polyWithTbl1l;
double polyAddOneh,polyAddOnem,polyAddOnel;
double polyWithTablesh, polyWithTablesm, polyWithTablesl;
#if EVAL_PERF
crlibm_second_step_taken++;
#endif
#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
highPoly = FMA(FMA(accPolyC7,rh,accPolyC6),rh,accPolyC5);
#else
highPoly = accPolyC5 + rh * (accPolyC6 + rh * accPolyC7);
#endif
Mul12(&t1h,&t1l,rh,highPoly);
Add22(&t2h,&t2l,accPolyC4h,accPolyC4l,t1h,t1l);
Mul22(&t3h,&t3l,rh,0,t2h,t2l);
Add22(&t4h,&t4l,accPolyC3h,accPolyC3l,t3h,t3l);
Mul12(&rhSquareh,&rhSquarel,rh,rh);
Mul23(&rhCubeh,&rhCubem,&rhCubel,rh,0,rhSquareh,rhSquarel);
rhSquareHalfh = 0.5 * rhSquareh;
rhSquareHalfl = 0.5 * rhSquarel;
Renormalize3(&lowPolyh,&lowPolym,&lowPolyl,rh,rhSquareHalfh,rhSquareHalfl);
Mul233(&highPolyMulth,&highPolyMultm,&highPolyMultl,t4h,t4l,rhCubeh,rhCubem,rhCubel);
Add33(&ph,&pm,&pl,lowPolyh,lowPolym,lowPolyl,highPolyMulth,highPolyMultm,highPolyMultl);
Add12(phnorm,pmnorm,ph,pm);
Mul22(&rmlMultPh,&rmlMultPl,rm,rl,phnorm,pmnorm);
Add22(&qh,&ql,rm,rl,rmlMultPh,rmlMultPl);
Add233Cond(&fullPolyh,&fullPolym,&fullPolyl,qh,ql,ph,pm,pl);
Add12(polyAddOneh,t5,1,fullPolyh);
Add12Cond(polyAddOnem,t6,t5,fullPolym);
polyAddOnel = t6 + fullPolyl;
Mul33(&polyWithTbl1h,&polyWithTbl1m,&polyWithTbl1l,tbl1h,tbl1m,tbl1l,polyAddOneh,polyAddOnem,polyAddOnel);
Mul33(&polyWithTablesh,&polyWithTablesm,&polyWithTablesl,
tbl2h,tbl2m,tbl2l,
polyWithTbl1h,polyWithTbl1m,polyWithTbl1l);
Renormalize3(polyTblh,polyTblm,polyTbll,polyWithTablesh,polyWithTablesm,polyWithTablesl);
}
void log_td_accurate(double *logh, double *logm, double *logl, int E, double ed, int index, double zh, double zl, double logih, double logim) {
double highPoly, t1h, t1l, t2h, t2l, t3h, t3l, t4h, t4l, t5h, t5l, t6h, t6l, t7h, t7l, t8h, t8l, t9h, t9l, t10h, t10l, t11h, t11l;
double t12h, t12l, t13h, t13l, t14h, t14l, zSquareh, zSquarem, zSquarel, zCubeh, zCubem, zCubel, higherPolyMultZh, higherPolyMultZm;
double higherPolyMultZl, zSquareHalfh, zSquareHalfm, zSquareHalfl, polyWithSquareh, polyWithSquarem, polyWithSquarel;
double polyh, polym, polyl, logil, logyh, logym, logyl, loghover, logmover, loglover, log2edhover, log2edmover, log2edlover;
double log2edh, log2edm, log2edl;
#if EVAL_PERF
crlibm_second_step_taken++;
#endif
/* Accurate phase:
Argument reduction is already done.
We must return logh, logm and logl representing the intermediate result in 118 bits precision.
We use a 14 degree polynomial, computing the first 3 (the first is 0) coefficients in triple double,
calculating the next 7 coefficients in double double arithmetics and the last in double.
We must account for zl starting with the monome of degree 4 (7^3 + 53 - 7 >> 118); so
double double calculations won't account for it.
*/
/* Start of the horner scheme */
#if defined(PROCESSOR_HAS_FMA) && !defined(AVOID_FMA)
highPoly = FMA(FMA(FMA(FMA(accPolyC14,zh,accPolyC13),zh,accPolyC12),zh,accPolyC11),zh,accPolyC10);
#else
highPoly = accPolyC10 + zh * (accPolyC11 + zh * (accPolyC12 + zh * (accPolyC13 + zh * accPolyC14)));
#endif
/* We want to write
accPolyC3 + zh * (accPoly4 + zh * (accPoly5 + zh * (accPoly6 + zh * (accPoly7 + zh * (accPoly8 + zh * (accPoly9 + zh * highPoly))))));
( t14 t13 t12 t11 t10 t9 t8 t7 t6 t5 t4 t3 t2 t1 )
with all additions and multiplications in double double arithmetics
but we will produce intermediate results labelled t1h/t1l thru t14h/t14l
*/
Mul12(&t1h, &t1l, zh, highPoly);
Add22(&t2h, &t2l, accPolyC9h, accPolyC9l, t1h, t1l);
Mul22(&t3h, &t3l, zh, zl, t2h, t2l);
Add22(&t4h, &t4l, accPolyC8h, accPolyC8l, t3h, t3l);
Mul22(&t5h, &t5l, zh, zl, t4h, t4l);
Add22(&t6h, &t6l, accPolyC7h, accPolyC7l, t5h, t5l);
Mul22(&t7h, &t7l, zh, zl, t6h, t6l);
Add22(&t8h, &t8l, accPolyC6h, accPolyC6l, t7h, t7l);
Mul22(&t9h, &t9l, zh, zl, t8h, t8l);
Add22(&t10h, &t10l, accPolyC5h, accPolyC5l, t9h, t9l);
Mul22(&t11h, &t11l, zh, zl, t10h, t10l);
Add22(&t12h, &t12l, accPolyC4h, accPolyC4l, t11h, t11l);
Mul22(&t13h, &t13l, zh, zl, t12h, t12l);
Add22(&t14h, &t14l, accPolyC3h, accPolyC3l, t13h, t13l);
/* We must now prepare (zh + zl)^2 and (zh + zl)^3 as triple doubles */
Mul23(&zSquareh, &zSquarem, &zSquarel, zh, zl, zh, zl);
Mul233(&zCubeh, &zCubem, &zCubel, zh, zl, zSquareh, zSquarem, zSquarel);
/* We can now multiplicate the middle and higher polynomial by z^3 */
Mul233(&higherPolyMultZh, &higherPolyMultZm, &higherPolyMultZl, t14h, t14l, zCubeh, zCubem, zCubel);
/* Multiply now z^2 by -1/2 (exact op) and add to middle and higher polynomial */
zSquareHalfh = zSquareh * -0.5;
zSquareHalfm = zSquarem * -0.5;
zSquareHalfl = zSquarel * -0.5;
Add33(&polyWithSquareh, &polyWithSquarem, &polyWithSquarel,
zSquareHalfh, zSquareHalfm, zSquareHalfl,
higherPolyMultZh, higherPolyMultZm, higherPolyMultZl);
/* Add now zh and zl to obtain the polynomial evaluation result */
Add233(&polyh, &polym, &polyl, zh, zl, polyWithSquareh, polyWithSquarem, polyWithSquarel);
/* Reconstruct now log(y) = log(1 + z) - log(ri) by adding logih, logim, logil
logil has not been read to the time, do this first
*/
logil = argredtable[index].logil;
Add33(&logyh, &logym, &logyl, logih, logim, logil, polyh, polym, polyl);
/* Multiply log2 with E, i.e. log2h, log2m, log2l by ed
ed is always less than 2^(12) and log2h and log2m are stored with at least 12 trailing zeros
So multiplying naively is correct (up to 134 bits at least)
The final result is thus obtained by adding log2 * E to log(y)
*/
log2edhover = log2h * ed;
log2edmover = log2m * ed;
log2edlover = log2l * ed;
/* It may be necessary to renormalize the tabulated value (multiplied by ed) before adding
the to the log(y)-result
If needed, uncomment the following Renormalize3-Statement and comment out the copies
following it.
*/
/* Renormalize3(&log2edh, &log2edm, &log2edl, log2edhover, log2edmover, log2edlover); */
log2edh = log2edhover;
log2edm = log2edmover;
log2edl = log2edlover;
Add33(&loghover, &logmover, &loglover, log2edh, log2edm, log2edl, logyh, logym, logyl);
/* Since we can not guarantee in each addition and multiplication procedure that
the results are not overlapping, we must renormalize the result before handing
it over to the final rounding
*/
Renormalize3(logh,logm,logl,loghover,logmover,loglover);
}
