int128.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	INT128

Macros
#define	USE_NATIVE_INT128   0
#define	INT64_AU32(i64)   ((i64) >> 32)
#define	INT64_AL32(i64)   ((i64) & UINT64CONST(0xFFFFFFFF))

Functions
static void	int128_add_uint64 (INT128 *i128, uint64 v)
static void	int128_add_int64 (INT128 *i128, int64 v)
static void	int128_add_int64_mul_int64 (INT128 *i128, int64 x, int64 y)
static int	int128_compare (INT128 x, INT128 y)
static INT128	int64_to_int128 (int64 v)
static int64	int128_to_int64 (INT128 val)

Macro Definition Documentation

INT64_AL32

#define INT64_AL32

(

i64

)

((i64) & UINT64CONST(0xFFFFFFFF))

Definition at line 171 of file int128.h.

INT64_AU32

#define INT64_AU32

(

i64

)

((i64) >> 32)

Definition at line 170 of file int128.h.

USE_NATIVE_INT128

#define USE_NATIVE_INT128   0

Definition at line 28 of file int128.h.

Function Documentation

int128_add_int64()

static void int128_add_int64 ( INT128 *  i128, int64  v  )

inlinestatic

Definition at line 143 of file int128.h.

{
    /*
     * This is much like the above except that the carry logic differs for
     * negative v.  Ordinarily we'd need to subtract 1 from the .hi part
     * (corresponding to adding the sign-extended bits of v to it); but if
     * there is a carry out of the .lo part, that cancels and we do nothing.
     */
    uint64      oldlo = i128->lo;
 
    i128->lo += v;
    if (v >= 0)
    {
        if ((int64) oldlo < 0 && (int64) i128->lo >= 0)
            i128->hi++;
    }
    else
    {
        if (!((int64) oldlo < 0 || (int64) i128->lo >= 0))
            i128->hi--;
    }
}

References INT128::hi, and INT128::lo.

Referenced by main().

int128_add_int64_mul_int64()

static void int128_add_int64_mul_int64 ( INT128 *  i128, int64  x, int64  y  )

inlinestatic

Definition at line 177 of file int128.h.

{
    /* INT64_AU32 must use arithmetic right shift */
    StaticAssertDecl(((int64) -1 >> 1) == (int64) -1,
                     "arithmetic right shift is needed");
 
    /*----------
     * Form the 128-bit product x * y using 64-bit arithmetic.
     * Considering each 64-bit input as having 32-bit high and low parts,
     * we can compute
     *
     *   x * y = ((x.hi << 32) + x.lo) * (((y.hi << 32) + y.lo)
     *         = (x.hi * y.hi) << 64 +
     *           (x.hi * y.lo) << 32 +
     *           (x.lo * y.hi) << 32 +
     *           x.lo * y.lo
     *
     * Each individual product is of 32-bit terms so it won't overflow when
     * computed in 64-bit arithmetic.  Then we just have to shift it to the
     * correct position while adding into the 128-bit result.  We must also
     * keep in mind that the "lo" parts must be treated as unsigned.
     *----------
     */
 
    /* No need to work hard if product must be zero */
    if (x != 0 && y != 0)
    {
        int64       x_u32 = INT64_AU32(x);
        uint64      x_l32 = INT64_AL32(x);
        int64       y_u32 = INT64_AU32(y);
        uint64      y_l32 = INT64_AL32(y);
        int64       tmp;
 
        /* the first term */
        i128->hi += x_u32 * y_u32;
 
        /* the second term: sign-extend it only if x is negative */
        tmp = x_u32 * y_l32;
        if (x < 0)
            i128->hi += INT64_AU32(tmp);
        else
            i128->hi += ((uint64) tmp) >> 32;
        int128_add_uint64(i128, ((uint64) INT64_AL32(tmp)) << 32);
 
        /* the third term: sign-extend it only if y is negative */
        tmp = x_l32 * y_u32;
        if (y < 0)
            i128->hi += INT64_AU32(tmp);
        else
            i128->hi += ((uint64) tmp) >> 32;
        int128_add_uint64(i128, ((uint64) INT64_AL32(tmp)) << 32);
 
        /* the fourth term: always unsigned */
        int128_add_uint64(i128, x_l32 * y_l32);
    }
}

References INT128::hi, int128_add_uint64(), INT64_AL32, INT64_AU32, StaticAssertDecl, x, and y.

Referenced by interval_cmp_value(), and main().

int128_add_uint64()

static void int128_add_uint64 ( INT128 *  i128, uint64  v  )

inlinestatic

Definition at line 122 of file int128.h.

{
    /*
     * First add the value to the .lo part, then check to see if a carry needs
     * to be propagated into the .hi part.  A carry is needed if both inputs
     * have high bits set, or if just one input has high bit set while the new
     * .lo part doesn't.  Remember that .lo part is unsigned; we cast to
     * signed here just as a cheap way to check the high bit.
     */
    uint64      oldlo = i128->lo;
 
    i128->lo += v;
    if (((int64) v < 0 && (int64) oldlo < 0) ||
        (((int64) v < 0 || (int64) oldlo < 0) && (int64) i128->lo >= 0))
        i128->hi++;
}

References INT128::hi, and INT128::lo.

Referenced by int128_add_int64_mul_int64(), and main().

int128_compare()

static int int128_compare ( INT128  x, INT128  y  )

inlinestatic

Definition at line 238 of file int128.h.

{
    if (x.hi < y.hi)
        return -1;
    if (x.hi > y.hi)
        return 1;
    if (x.lo < y.lo)
        return -1;
    if (x.lo > y.lo)
        return 1;
    return 0;
}

References x, and y.

Referenced by interval_cmp_internal(), interval_sign(), and main().

int128_to_int64()

static int64 int128_to_int64 ( INT128  val )

inlinestatic

Definition at line 269 of file int128.h.

{
    return (int64) val.lo;
}

References val.

Referenced by interval_hash(), and interval_hash_extended().

int64_to_int128()

static INT128 int64_to_int128 ( int64  v )

inlinestatic

Definition at line 255 of file int128.h.

{
    INT128      val;
 
    val.lo = (uint64) v;
    val.hi = (v < 0) ? -INT64CONST(1) : INT64CONST(0);
    return val;
}

References INT64CONST, and val.

Referenced by interval_cmp_value(), and interval_sign().