/***********************************************************************
Test a pair-precision Pochhammer function using the version-1 2sum
algorithm (which is NOT valid for any base > 3; use
pochpp2-dec.c instead). This version does the computations in
decimal floating-point arithmetic

Usage:
	dgcc [-DMAXTEST=nnn] [-DMAXN=nnn] [-DMAXX=d.dd]  \
	     [-DTEST1 | -DTEST2] [-DUSE_FLOAT] pochpp1-dec.c && \
            ./a.out > pochpp1-dec.dat

[11-Aug-2026]
***********************************************************************/

#include <errno.h>
#include <decfloat.h>
#include <mathcw.h>
#include <stdio.h>
#include <stdlib.h>
#include <randcw.h>

#if !defined(TEST1) && !defined(TEST2)
#define TEST1
#endif

#if !defined(MAXTEST)
#define MAXTEST 250
#endif /* !defined(MAXTEST) */

#if !defined(MAXN)
#define MAXN 251
#endif /* !defined(MAXN) */

#if !defined(MAXX)
#define MAXX FP(1024.)
#endif /* !defined(MAXX) */

#define CONS(a,b) a##b

#if defined(USE_FLOAT)
typedef decimal_float fp_t;
typedef decimal_long_double hp_t;
const fp_t EPS       = DEC32_EPSILON;
const fp_t MINNORMAL = DEC32_MIN;
const int FP_T_MANT_DIG = DEC32_MANT_DIG;
const int HP_T_MANT_DIG = DEC128_MANT_DIG;
#define EXP(x)		expdf(x)
#define FABS(x)		fabsdf(x)
#define FMA(x,y,z)	fmafdf(x,y,z)
#define FP(x)		CONS(x,DF)
#define INFTY(x)	inftydf(x)
#define LOG(x)		logdf(x)
#define QNAN(s) 	nandf(s)
#else
typedef decimal_double fp_t;
typedef decimal_long_double hp_t;
const fp_t EPS       = DEC64_EPSILON;
const fp_t MINNORMAL = DEC64_MIN;
const int FP_T_MANT_DIG = DEC64_MANT_DIG;
const int HP_T_MANT_DIG = DEC128_MANT_DIG;
#define EXP(x)		expd(x)
#define FABS(x)		fabsd(x)
#define FMA(x,y,z)	fmad(x,y,z)
#define FP(x)		CONS(x, DD)
#define INFTY(x)	inftyd(x)
#define LOG(x)		logd(x)
#define QNAN(s) 	nand(s)
#endif /* defined(USE_FLOAT) */

static fp_t ONE = FP(1.0);
static fp_t ZERO = FP(0.0);

#define iseven(n) ((n & 1) == 0)

typedef struct { fp_t hi; fp_t lo; } pair_t;

pair_t
makepair(fp_t hi, fp_t lo)
{
    pair_t result;

    result.hi = hi;
    result.lo = lo;

    return (result);
}


pair_t
twomul(fp_t x, fp_t y)
{
    fp_t xy;

    xy = x * y;

    return (makepair(xy, FMA(x, y, -xy)));
}

#if defined(USE_ALT_TWOSUM)
pair_t
twosum(fp_t x, fp_t y)
{
    fp_t err, sum;
    volatile fp_t t1, t2, t3, t4;

    sum = x + y;
    t1 = sum - y;
    t2 = sum - t1;
    t3 = x - t1;
    t4 = y - t2;
    err = t3 + t4;

    return (makepair(sum, err));
}
#else
pair_t
twosum(fp_t x, fp_t y)
{
    volatile fp_t err, sum, tmp;

    if (FABS(x) >= FABS(y))
    {
	sum = x + y;
	tmp = sum - x;
	err = y - tmp;
    }
    else
    {
	sum = x + y;
	tmp = sum - y;
	err = x - tmp;
    }

    return (makepair(sum, err));
}
#endif

pair_t
Vsum(fp_t v[/* n */], int n)
{
    fp_t err, sum;
    int k;
    pair_t the_sum;

    err = ZERO;
    sum = ZERO;

    for (k = 0; k < n; ++k)
    {
	the_sum = twosum(sum, v[k]);
	sum = the_sum.hi;
	err += the_sum.lo;
    }

    return (makepair(sum, err));
}

pair_t
pairmul(pair_t x, pair_t y)
{
    pair_t the_prod;
    fp_t v[8];

    the_prod = twomul(x.hi, y.hi);
    v[0] = the_prod.hi;
    v[1] = the_prod.lo;

    the_prod = twomul(x.hi, y.lo);
    v[2] = the_prod.hi;
    v[3] = the_prod.lo;

    the_prod = twomul(x.lo, y.hi);
    v[4] = the_prod.hi;
    v[5] = the_prod.lo;

    the_prod = twomul(x.lo, y.lo);
    v[6] = the_prod.hi;
    v[7] = the_prod.lo;

    return (Vsum(v, 8));
}

pair_t
pairsum(pair_t x, pair_t y)
{
    fp_t v[4];

    v[0] = x.hi;
    v[1] = y.hi;
    v[2] = x.lo;
    v[3] = y.lo;

    return (Vsum(v, 4));
}

pair_t
poch_pp_std(fp_t x, int n)
{
    pair_t prod;
    int k;

    if (isnan(x))	/* generate run-time NaN, preserve payload */
    {
	errno = ERANGE;
	(void)QNAN("");
	prod = makepair(x, x);
    }
    else if (n < 0)
    {
	errno = ERANGE;
	prod = makepair(QNAN("0xfac50000"), QNAN("0xfac50000"));
    }
    else if (x == ZERO)
	prod = makepair(x, x); /* NB: preserve sign of zero! */
    else if (n == 0)
	prod = makepair(ONE, ZERO);
    else if (n == 1)
	prod = makepair(x, ZERO);
    else if (isinf(x))
	prod = (x > ZERO) ? makepair(x, ZERO) :
	    (iseven(n) ? makepair(-x, ZERO) : makepair(x, ZERO));
    else
    {
	prod = makepair(x, ZERO);

	for (k = 1; k < n; ++k)
	    prod = pairmul(prod, twosum(x, (fp_t)k));

	/* NB: intermediate overflow produces NaN parts,
	   NOT Infinity! */
	if (isnan(prod.hi) || isnan(prod.lo))
	    prod = makepair(INFTY(), ZERO); /* NB: this assumes x >= 0 */
    }

    return (prod);
}

fp_t
poch_simple(fp_t x, int n)
{
    fp_t result;
    int k;

    if (isnan(x))	/* generate run-time NaN, preserve payload */
    {
	errno = ERANGE;
	(void)QNAN("");
	result = x;
    }
    else if (n < 0)
    {
	errno = ERANGE;
	result = QNAN("0xfac50000");
    }
    else if (x == ZERO)
	result = x;	/* NB: preserve sign of zero! */
    else if (n == 0)
	result = ONE;
    else if (n == 1)
	result = x;
    else if (isinf(x))
	result = (x > ZERO) ? x : (iseven(n) ? -x : x);
    else
    {
	result = x;

	for (k = 1; k < n; ++k)
	    result *= (x + (fp_t)k);
    }

    return (result);
}

static hp_t
poch_hp(fp_t x, int n)
{   /*
    ** Pochhammer symbol, with standard mathematical notation (x)_n,
    ** defined by:
    **
    **     (x)_n = (x + 0) * (x + 1) * (x + 2) * ... * (x + n - 1)
    **
    ** Special cases: (+/-0)_n = +/-0, (x)_0 = 1, and (x)_1 = x
    **
    ** Identities: (1)_n = n! and (2)_n = (n + 1)!
    */

    hp_t result;

    if (isnan(x))	/* generate run-time NaN, preserve payload */
    {
        errno = ERANGE;
	(void)nan("");
	result = x;
    }
    else if (n < 0)
    {
	errno = ERANGE;
	result = QNAN("0xfac50000");
    }
    else if (x == ZERO)
	result = x;	/* NB: preserve sign of zero! */
    else if (n == 0)
	result = ONE;
    else if (n == 1)
	result = x;
    else if (isinf(x))
	result = (x > (fp_t)0.0) ? x : (iseven(n) ? -x : x);
    else
    {
	int k;
	hp_t prod, xx;

	prod = (hp_t)ONE;
	xx = (hp_t)x;

	for (k = 0; k < n; ++k)
	    prod *= (xx + (hp_t)k);

	result = prod;
    }

    return (result);
}

#if defined(TEST2)

static const int __NPOCH_DAQ__ = 10;

static fp_t
poch_pp_daq(fp_t x, int n)
{
    fp_t result;

    if (n < __NPOCH_DAQ__)
    {
	pair_t p;
	p = poch_pp_std(x, n);
	result = p.hi;
    }
    else
    {
	int m;

	m = n / 2;
	result = poch_pp_daq(x, m) * poch_pp_daq(x + m, n - m);
    }

    return (result);
}

#endif /* defined(TEST2) */

fp_t
Rand(void)
{
    return ((fp_t)drand48());
}

int
main(void)
{
    fp_t a, ulp, ulpmax, ulpsum, x;
    hp_t e;
    int k, n, nsum;

    srand48(0xcafefeed);
    nsum = 0;
    ulpsum = ZERO;
    ulpmax = ZERO;

    (void)fprintf(stderr, "hp_t is decimal%d\n", HP_T_MANT_DIG);

#if defined(TEST1)

    (void)fprintf(stderr, "Test of poch_pp_std() in decimal%d\n", FP_T_MANT_DIG);

    for (k = 0; k < MAXTEST; ++k)
    {
	x = Rand() * MAXX;

	for (n = 2; n < MAXN; ++n)
	{
	    pair_t p;

	    e = poch_hp(x, n);
	    p = poch_pp_std(x, n);
	    a = p.hi;

	    if (isinf((fp_t)e))
		break;

	    ulp = (fp_t)(((hp_t)a - e) / e) / EPS;

	    if (isinf(ulp))
		continue;

	    ++nsum;
	    ulpsum += FABS(ulp);

	    if (FABS(ulpmax) < FABS(ulp))
		ulpmax = ulp;

	    (void)printf("%7d\t%15.7DDf\t%15.7DDf\n", 
			 n, (decimal_double)x, (decimal_double)ulp);
	}
    }

    (void)fprintf(stderr, "Average ulps for poch_pp_std() = %.7DDf\n", (decimal_double)ulpsum / (decimal_double)nsum);
    (void)fprintf(stderr, "Maximum ulps for poch_pp_std() = %.7DDf\n", (decimal_double)ulpmax);
    (void)fprintf(stderr, "Sample count for poch_pp_std() = %7d\n", nsum);

#elif defined(TEST2)

    (void)fprintf(stderr, "Test of poch_pp_daq() in decimal%d\n", FP_T_MANT_DIG);

    for (k = 0; k < MAXTEST; ++k)
    {
	x = Rand() * MAXX;

	for (n = 2; n < MAXN; ++n)
	{
	    e = poch_hp(x, n);
	    a = poch_pp_daq(x, n);

	    if (isinf((fp_t)e))
		break;

	    ulp = (fp_t)(((hp_t)a - e) / e) / EPS;

	    if (isinf(ulp))
		continue;

	    ++nsum;
	    ulpsum += FABS(ulp);

	    if (FABS(ulpmax) < FABS(ulp))
		ulpmax = ulp;

	    (void)printf("%7d\t%15.7DDf\t%15.7DDf\n", 
			 n, (decimal_double)x, (decimal_double)ulp);
	}
    }

    (void)fprintf(stderr, "Average ulps for poch_pp_daq() = %.7DDf\n", (decimal_double)ulpsum / (decimal_double)nsum);
    (void)fprintf(stderr, "Maximum ulps for poch_pp_daq() = %.7DDf\n", (decimal_double)ulpmax);
    (void)fprintf(stderr, "Sample count for poch_pp_daq() = %7d\n", nsum);

#endif /* defined(TEST1) */

    return (EXIT_SUCCESS);
}
