/*
** Implement poch_pp(x,n) using pair-precision arithmetic.
**
** Usage:
**	% gcc-17 [-DUSE_ALT_TWOSUM]	\
**		 [-DUSE_FLOAT]		\
**		 [-DUSE_LONG_DOUBLE]	\
**            -Wall -pedantic twosum.c -lm && ./a.out
**
** [13-Jul-2026]
*/

#include <errno.h>
#include <float.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>

#if defined(USE_FLOAT)

typedef float fp_t;
#define FMT_A		"%a"
#define FMT_G		"%.9g"
#define FABS(x)		fabsf(x)
#define FMA(x,y,z)	fmaf((x), (y), (z))

#elif defined(USE_LONG_DOUBLE)

typedef long double fp_t;
#define FMT_A		"%La"

#if LDBL_MANT_DIG == 64
#define FMT_G		"%.21Lg"
#else
#define FMT_G		"%.36Lg"
#endif

#define FABS(x)		fabsl(x)
#define FMA(x,y,z)	fmal((x), (y), (z))

#else

#define FMT_A		"%a"
#define FMT_G		"%.17g"
typedef double fp_t;
#define FABS(x)		fabs(x)
#define FMA(x,y,z)	fma((x), (y), (z))

#endif	/* defined(USE_FLOAT) */

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

static const fp_t ONE = (fp_t)1.;
static const fp_t ZERO = (fp_t)0.;

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

fp_t
infty(void)
{
    volatile fp_t x;

    x = ZERO;

    return (ONE / x);
}

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

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

    return (result);
}


fp_t
qnan(const char *s)
{
    volatile fp_t x;

    x = (s == (const char *)NULL)? ZERO : ZERO;

    return (x / x);
}

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(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);
}

void
test(fp_t x, int n)
{
    fp_t r;
    pair_t p;

    p = poch_pp(x, n);
    (void)printf("poch_pp    (%5.2f, %2d) = [" FMT_G " + " FMT_G "]\n",
		 (double)x, (int)n, p.hi, p.lo);

    r = poch_simple(x, n);
    (void)printf("poch_simple(%5.2f, %2d) = [" FMT_G "]\n",
		 (double)x, (int)n, r);
}

int
main(void)
{
    fp_t x;
    static const fp_t PI = (fp_t)+0x1.921fb54442d18469898cc51701b84p+1L;

    for (x = (fp_t)0.; x <= (fp_t)2.; x += (fp_t)0.25)
	test(x, 10);

    test(PI, 0);
    test(PI, 1);
    test(PI, 2);
    test(PI, 10);
    test(PI, 150);
    test(PI, 2122);

    for (x = (fp_t)500.; x <= (fp_t)2500.; x += (fp_t)500.)
	test(x, 10);

    test(infty(), 10);
    test(infty(), 11);

    test(-infty(), 10);
    test(-infty(), 11);

    test(qnan(""), 10);
    test(qnan(""), 11);

    return (EXIT_SUCCESS);
}
