[Commit] cairo_u128 ChangeLog, 1.2, 1.3 Makefile, 1.4, 1.5 cairo_test.c, 1.4, 1.5 cairo_uint128.c, 1.4, 1.5 cairo_uint128.h, 1.4, 1.5 checkdata.5c, 1.4, 1.5 makedata.5c, 1.2, 1.3

Keith Packard commit at keithp.com
Thu May 27 22:47:19 PDT 2004


Committed by: keithp

Update of /local/src/CVS/cairo_u128
In directory home.keithp.com:/tmp/cvs-serv13286

Modified Files:
	ChangeLog Makefile cairo_test.c cairo_uint128.c 
	cairo_uint128.h checkdata.5c makedata.5c 
Log Message:
2004-05-27  Keith Packard  <keithp at keithp.com>

	* Makefile:
	* cairo_test.c: (zero_dump_uint64), (dump_uint64), (dump_int64),
	(dump_uint128), (dump_int128), (read_int128), (_nz_den128),
	(_nz_den64), (main):
	* cairo_uint128.c: (_cairo_uint64_divrem),
	(_cairo_uint32_to_uint64), (_cairo_int32_to_int64),
	(_cairo_uint32s_to_uint64), (_cairo_uint64_add),
	(_cairo_uint64_sub), (_cairo_uint32x32_64_mul),
	(_cairo_uint64_mul), (_cairo_uint64_lsl), (_cairo_uint64_rsl),
	(_cairo_uint64_rsa), (_cairo_uint64_lt), (_cairo_uint64_eq),
	(_cairo_int64_lt), (_cairo_uint64_not), (_cairo_uint64_negate),
	(_cairo_uint64x32_normalized_divrem), (_cairo_int64_divrem),
	(_cairo_uint128_divrem), (_cairo_uint32_to_uint128),
	(_cairo_int32_to_int128), (_cairo_uint64_to_uint128),
	(_cairo_int64_to_int128), (_cairo_uint128_add),
	(_cairo_uint128_sub), (uint64_lo), (uint64_hi), (uint64_shift32),
	(_cairo_uint64x64_128_mul), (_cairo_uint128_mul),
	(_cairo_uint128_lsl), (_cairo_uint128_rsl), (_cairo_uint128_rsa),
	(_cairo_uint128_lt), (_cairo_int128_lt), (_cairo_uint128_eq),
	(_cairo_uint128x64_normalized_divrem), (_cairo_leading_zeros64),
	(_cairo_int128_divrem), (_cairo_int128_negate),
	(_cairo_int128_not):
	* cairo_uint128.h:
	* checkdata.5c:
	* makedata.5c:
	Add signed arithmetic.  Test all operations.
	Allow for 'native' int128_t.


Index: ChangeLog
===================================================================
RCS file: /local/src/CVS/cairo_u128/ChangeLog,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- a/ChangeLog	25 May 2004 21:21:52 -0000	1.2
+++ b/ChangeLog	28 May 2004 05:47:16 -0000	1.3
@@ -1,3 +1,33 @@
+2004-05-27  Keith Packard  <keithp at keithp.com>
+
+	* Makefile:
+	* cairo_test.c: (zero_dump_uint64), (dump_uint64), (dump_int64),
+	(dump_uint128), (dump_int128), (read_int128), (_nz_den128),
+	(_nz_den64), (main):
+	* cairo_uint128.c: (_cairo_uint64_divrem),
+	(_cairo_uint32_to_uint64), (_cairo_int32_to_int64),
+	(_cairo_uint32s_to_uint64), (_cairo_uint64_add),
+	(_cairo_uint64_sub), (_cairo_uint32x32_64_mul),
+	(_cairo_uint64_mul), (_cairo_uint64_lsl), (_cairo_uint64_rsl),
+	(_cairo_uint64_rsa), (_cairo_uint64_lt), (_cairo_uint64_eq),
+	(_cairo_int64_lt), (_cairo_uint64_not), (_cairo_uint64_negate),
+	(_cairo_uint64x32_normalized_divrem), (_cairo_int64_divrem),
+	(_cairo_uint128_divrem), (_cairo_uint32_to_uint128),
+	(_cairo_int32_to_int128), (_cairo_uint64_to_uint128),
+	(_cairo_int64_to_int128), (_cairo_uint128_add),
+	(_cairo_uint128_sub), (uint64_lo), (uint64_hi), (uint64_shift32),
+	(_cairo_uint64x64_128_mul), (_cairo_uint128_mul),
+	(_cairo_uint128_lsl), (_cairo_uint128_rsl), (_cairo_uint128_rsa),
+	(_cairo_uint128_lt), (_cairo_int128_lt), (_cairo_uint128_eq),
+	(_cairo_uint128x64_normalized_divrem), (_cairo_leading_zeros64),
+	(_cairo_int128_divrem), (_cairo_int128_negate),
+	(_cairo_int128_not):
+	* cairo_uint128.h:
+	* checkdata.5c:
+	* makedata.5c:
+	Add signed arithmetic.  Test all operations.
+	Allow for 'native' int128_t.
+
 2004-05-25  Keith Packard  <keithp at keithp.com>
 
 	* Makefile:

Index: Makefile
===================================================================
RCS file: /local/src/CVS/cairo_u128/Makefile,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- a/Makefile	25 May 2004 21:21:52 -0000	1.4
+++ b/Makefile	28 May 2004 05:47:16 -0000	1.5
@@ -1,26 +1,27 @@
-SETS=10000
-REPS=100
+include params
 HAVE_UINT64_T=1
+HAVE_UINT128_T=0
+CDEBUGFLAGS=-O4
 
-CFLAGS=-O4 -DHAVE_UINT64_T=$(HAVE_UINT64_T)
+CFLAGS=$(CDEBUGFLAGS) -DHAVE_UINT64_T=$(HAVE_UINT64_T) -DHAVE_UINT128_T=$(HAVE_UINT128_T)
 OBJS = cairo_uint128.o cairo_test.o
 
 check: c nickle
 	cmp c nickle
 
-c: cairo_test data Makefile
+c: cairo_test data params
 	./cairo_test $(SETS) < data > $@
 
-nickle: checkdata.5c data Makefile
+nickle: checkdata.5c data
 	./checkdata.5c < data > $@
 
-data: makedata.5c Makefile
+data: makedata.5c params
 	./makedata.5c $(SETS) > data
 
 cairo_test: $(OBJS)
 	$(CC) $(CFLAGS) -o $@ $(OBJS)
 
-bench: cairo_test data Makefile
+bench: cairo_test data params
 	time ./cairo_test $(SETS) $(REPS) < data
 
 $(OBJS): cairo_uint128.h Makefile

Index: cairo_test.c
===================================================================
RCS file: /local/src/CVS/cairo_u128/cairo_test.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- a/cairo_test.c	25 May 2004 21:21:52 -0000	1.4
+++ b/cairo_test.c	28 May 2004 05:47:16 -0000	1.5
@@ -33,10 +33,10 @@
 #if HAVE_UINT64_T
     printf (zero ? "%016llx" : "%llx", q);
 #else
-    if (q.b[1] || zero)
-	printf (zero ? "%08x%08x" : "%x%08x", q.b[1], q.b[0]);
+    if (q.hi || zero)
+	printf (zero ? "%08x%08x" : "%x%08x", q.hi, q.lo);
     else
-	printf ("%x", q.b[0]);
+	printf ("%x", q.lo);
 #endif
 }
 
@@ -44,7 +44,17 @@
 dump_uint64 (cairo_uint64_t q)
 {
     zero_dump_uint64 (q, 0);
-    printf ("\n");
+}
+
+void
+dump_int64 (cairo_int64_t d)
+{
+    if (_cairo_int64_negative (d))
+    {
+	printf ("-");
+	d = _cairo_int64_negate (d);
+    }
+    dump_uint64 (_cairo_int64_to_uint64 (d));
 }
 
 void
@@ -52,22 +62,33 @@
 {
     int	    zero = 0;
     
-    if (_cairo_uint64_ne(q.b[1], _cairo_uint32_to_uint64(0)))
+    if (_cairo_uint64_ne(q.hi, _cairo_uint32_to_uint64(0)))
     {
-	zero_dump_uint64 (q.b[1], 0);
+	zero_dump_uint64 (q.hi, 0);
 	zero = 1;
     }
-    zero_dump_uint64 (q.b[0], zero);
-    printf ("\n");
+    zero_dump_uint64 (q.lo, zero);
 }
 
-cairo_uint128_t
-read_uint128 (FILE *f)
+void
+dump_int128 (cairo_int128_t d)
 {
-    cairo_uint128_t x;
+    if (_cairo_int128_negative (d))
+    {
+	printf ("-");
+	d = _cairo_int128_negate (d);
+    }
+    dump_uint128 (_cairo_int128_to_uint128 (d));
+}
+
+cairo_int128_t
+read_int128 (FILE *f)
+{
+    cairo_int128_t x;
     int		    c;
+    int		    neg = 0;
 
-    x = _cairo_uint32_to_uint128 (0);
+    x = _cairo_int32_to_int128 (0);
     while ((c = getc (f)) != EOF)
 	if (isxdigit (c))
 	{
@@ -81,38 +102,197 @@
 		    v = c - 'a' + 10;
 		else if ('A' <= c && c <= 'F')
 		    v = c - 'A' + 10;
-		x = _cairo_uint128_lsl (x, 4);
-		x = _cairo_uint128_add (x, _cairo_uint32_to_uint128 (v));
+		x = _cairo_int128_lsl (x, 4);
+		x = _cairo_int128_add (x, _cairo_int32_to_int128 (v));
 		c = getc (f);
 	    } while (isxdigit (c));
 	    if (c != EOF)
 		ungetc (c, f);
+	    if (neg)
+		x = _cairo_int128_negate (x);
 	    return x;
-	}
+	} else if (c == '-')
+	    neg = 1;
     exit (0);
 }
 
+typedef struct _op {
+    char		*name;
+    int			(*valid128) (cairo_int128_t, cairo_int128_t);
+    cairo_int128_t	(*s128) (cairo_int128_t, cairo_int128_t);
+    cairo_uint128_t	(*u128) (cairo_uint128_t, cairo_uint128_t);
+    int			(*valid64) (cairo_int64_t, cairo_int64_t);
+    cairo_int64_t	(*s64) (cairo_int64_t, cairo_int64_t);
+    cairo_uint64_t	(*u64) (cairo_uint64_t, cairo_uint64_t);
+} Op;
+
+#define declare(name) \
+cairo_int128_t \
+f_cairo_int128_##name (cairo_int128_t a, cairo_int128_t b) { \
+    return _cairo_int128_##name (a, b); \
+} \
+cairo_uint128_t \
+f_cairo_uint128_##name (cairo_uint128_t a, cairo_uint128_t b) { \
+    return _cairo_uint128_##name (a, b); \
+} \
+cairo_int64_t \
+f_cairo_int64_##name (cairo_int64_t a, cairo_int64_t b) { \
+    return _cairo_int64_##name (a, b); \
+} \
+cairo_uint64_t \
+f_cairo_uint64_##name (cairo_uint64_t a, cairo_uint64_t b) { \
+    return _cairo_uint64_##name (a, b); \
+} \
+
+#define declare_shift(name) \
+cairo_int128_t \
+f_cairo_int128_##name (cairo_int128_t a, cairo_int128_t b) { \
+    return _cairo_int128_##name (a, _cairo_uint128_to_uint32(b) & 127); \
+} \
+cairo_uint128_t \
+f_cairo_uint128_##name (cairo_uint128_t a, cairo_uint128_t b) { \
+    return _cairo_uint128_##name (a, _cairo_uint128_to_uint32(b) & 127); \
+} \
+cairo_int64_t \
+f_cairo_int64_##name (cairo_int64_t a, cairo_int64_t b) { \
+    return _cairo_int64_##name (a, _cairo_uint64_to_uint32(b) & 63); \
+} \
+cairo_uint64_t \
+f_cairo_uint64_##name (cairo_uint64_t a, cairo_uint64_t b) { \
+    return _cairo_uint64_##name (a, _cairo_uint64_to_uint32(b) & 63); \
+} \
+
+#define declare_divrem(elt) \
+cairo_int128_t \
+f_cairo_int128_##elt (cairo_int128_t a, cairo_int128_t b) { \
+    return _cairo_int128_divrem (a, b).elt; \
+} \
+cairo_uint128_t \
+f_cairo_uint128_##elt (cairo_uint128_t a, cairo_uint128_t b) { \
+    return _cairo_uint128_divrem (a, b).elt; \
+} \
+cairo_int64_t \
+f_cairo_int64_##elt (cairo_int64_t a, cairo_int64_t b) { \
+    return _cairo_int64_divrem (a, b).elt; \
+} \
+cairo_uint64_t \
+f_cairo_uint64_##elt (cairo_uint64_t a, cairo_uint64_t b) { \
+    return _cairo_uint64_divrem (a, b).elt; \
+} \
+
+#define declare_unary(name) \
+cairo_int128_t \
+f_cairo_int128_##name (cairo_int128_t a, cairo_int128_t b) { \
+    return _cairo_int128_##name (a); \
+} \
+cairo_uint128_t \
+f_cairo_uint128_##name (cairo_uint128_t a, cairo_uint128_t b) { \
+    return _cairo_uint128_##name (a); \
+} \
+cairo_int64_t \
+f_cairo_int64_##name (cairo_int64_t a, cairo_int64_t b) { \
+    return _cairo_int64_##name (a); \
+} \
+cairo_uint64_t \
+f_cairo_uint64_##name (cairo_uint64_t a, cairo_uint64_t b) { \
+    return _cairo_uint64_##name (a); \
+} \
+
+#define declare_bool(name) \
+cairo_int128_t \
+f_cairo_int128_##name (cairo_int128_t a, cairo_int128_t b) { \
+    return _cairo_int32_to_int128 (_cairo_int128_##name (a, b)); \
+} \
+cairo_uint128_t \
+f_cairo_uint128_##name (cairo_uint128_t a, cairo_uint128_t b) { \
+    return _cairo_int32_to_int128 (_cairo_uint128_##name (a, b)); \
+} \
+cairo_int64_t \
+f_cairo_int64_##name (cairo_int64_t a, cairo_int64_t b) { \
+    return _cairo_int32_to_int64 (_cairo_int64_##name (a, b)); \
+} \
+cairo_uint64_t \
+f_cairo_uint64_##name (cairo_uint64_t a, cairo_uint64_t b) { \
+    return _cairo_int32_to_int64 (_cairo_uint64_##name (a, b)); \
+} \
+
+declare (add)
+declare (sub)
+declare (mul)
+declare_shift (lsl)
+declare_shift (rsl)
+declare_shift (rsa)
+declare_divrem (quo)
+declare_divrem (rem)
+declare_unary (negate)
+declare_bool (lt)
+declare_bool (le)
+declare_bool (eq)
+declare_bool (ne)
+declare_bool (ge)
+declare_bool (gt)
+
+#define ops(name) \
+    0, f_cairo_int128_##name, f_cairo_uint128_##name, \
+    0, f_cairo_int64_##name, f_cairo_uint64_##name,
+
+int
+_nz_den128 (cairo_int128_t num, cairo_int128_t den)
+{
+    return _cairo_int128_ne (den, _cairo_int32_to_int128 (0));
+}
+
+int
+_nz_den64 (cairo_int64_t num, cairo_int64_t den)
+{
+    return _cairo_int64_ne (den, _cairo_int32_to_int64 (0));
+}
+
+#define div_ops(name) \
+    _nz_den128, f_cairo_int128_##name, f_cairo_uint128_##name, \
+    _nz_den64, f_cairo_int64_##name, f_cairo_uint64_##name,
+
+Op ops[] = {
+    { "+", ops (add) },
+    { "-", ops (sub) },
+    { "*", ops (mul) },
+    { ">>", ops (rsl) },
+    { ">>>", ops (rsa) },
+    { "<<", ops (lsl) },
+    { "/", div_ops(quo) },
+    { "%", div_ops(rem) },
+    { "<", ops (lt) },
+    { "<=", ops (le) },
+    { "==", ops (eq) },
+    { "!=", ops (ne) },
+    { ">=", ops (ge) },
+    { ">", ops (gt) },
+};
+
+#define N_OP (sizeof (ops) / sizeof (ops[0]))
+
 int
 main (int argc, char **argv)
 {
     unsigned int    i;
-    cairo_uint128_t *q, qv;
-    cairo_uint64_t  *d, dv;
+    cairo_int128_t  *q, qv;
+    cairo_int64_t   *d, dv;
     int		    c;
     int		    width = 2;
     int		    sets = atoi (argv[1]);
     int		    reps = argv[2] ? atoi(argv[2]) : 1;
     int		    r;
     int		    s;
+    int		    op;
 
-    q = malloc (width * sets * sizeof (cairo_uint128_t));
-    d = malloc (width * sets * sizeof (cairo_uint64_t));
+    q = malloc (width * sets * sizeof (cairo_int128_t));
+    d = malloc (width * sets * sizeof (cairo_int64_t));
     for (s = 0; s < sets; s++)
     {
 	for (c = 0; c < width; c++)
 	{
-	    q[c + s*width] = read_uint128 (stdin);
-	    d[c + s*width] = _cairo_uint128_to_uint64 (q[c+s*width]);
+	    q[c + s*width] = read_int128 (stdin);
+	    d[c + s*width] = _cairo_int128_to_int64 (q[c+s*width]);
 	}
     }
     for (r = 0; r < reps; r++)
@@ -121,111 +301,71 @@
 	{
 	    if (reps == 1)
 	    {
+		printf ("s  64 ");
+		dump_int64 (d[0+s*width]);
+		printf (" ");
+		dump_int64 (d[1+s*width]);
+		printf ("\n");
+		printf ("u  64 ");
+		dump_uint64 (d[0+s*width]);
+		printf (" ");
+		dump_uint64 (d[1+s*width]);
+		printf ("\n");
+		printf ("s 128 ");
+		dump_int128 (q[0+s*width]);
+		printf (" ");
+		dump_int128 (q[1+s*width]);
+		printf ("\n");
+		printf ("u 128 ");
 		dump_uint128 (q[0+s*width]);
+		printf (" ");
 		dump_uint128 (q[1+s*width]);
+		printf ("\n");
+		printf ("\n");
 	    }
 	    
-	    qv = _cairo_uint128_add (q[0+s*width], q[1+s*width]);
-	    if (reps == 1)
-	    {
-		printf ("+ ");
-		dump_uint128 (qv);
-	    }
-	    
-	    dv = _cairo_uint64_add (d[0+s*width], d[1+s*width]);
-	    if (reps == 1)
-	    {
-		printf ("+ ");
-		dump_uint64 (dv);
-	    }
-	    
-	    qv = _cairo_uint128_sub (q[0+s*width], q[1+s*width]);
-	    if (reps == 1)
-	    {
-		printf ("- ");
-		dump_uint128 (qv);
-	    }
-	    
-	    dv = _cairo_uint64_sub (d[0+s*width], d[1+s*width]);
-	    if (reps == 1)
-	    {
-		printf ("- ");
-		dump_uint64 (dv);
-	    }
-	    
-	    qv = _cairo_uint128_mul (q[0+s*width], q[1+s*width]);
-	    if (reps == 1)
-	    {
-		printf ("* ");
-		dump_uint128 (qv);
-	    }
-	    
-	    dv = _cairo_uint64_mul (d[0+s*width], d[1+s*width]);
-	    if (reps == 1)
-	    {
-		printf ("* ");
-		dump_uint64 (dv);
-	    }
-	    
-	    qv = _cairo_uint128_rsl (q[0+s*width],
-				     _cairo_uint128_to_uint32(q[1+s*width]) % 128);
-	    if (reps == 1)
-	    {
-		printf (">> ");
-		dump_uint128 (qv);
-	    }
-	    
-	    dv = _cairo_uint64_rsl (d[0+s*width],
-				    _cairo_uint64_to_uint32(d[1+s*width]) % 64);
-	    if (reps == 1)
-	    {
-		printf (">> ");
-		dump_uint64 (dv);
-	    }
-	    
-	    qv = _cairo_uint128_lsl (q[0+s*width],
-				     _cairo_uint128_to_uint32(q[1+s*width]) % 128);
-	    if (reps == 1)
-	    {
-		printf ("<< ");
-		dump_uint128 (qv);
-	    }
-	    
-	    dv = _cairo_uint64_lsl (d[0+s*width],
-				    _cairo_uint64_to_uint32(d[1+s*width]) % 64);
-	    if (reps == 1)
-	    {
-		printf ("<< ");
-		dump_uint64 (dv);
-	    }
-	    
-	    qv = _cairo_uint128_divmod (q[0+s*width], q[1+s*width]).quo;
-	    if (reps == 1)
-	    {
-		printf ("/ ");
-		dump_uint128 (qv);
-	    }
-	    
-	    dv = _cairo_uint64_divmod (d[0+s*width], d[1+s*width]).quo;
-	    if (reps == 1)
-	    {
-		printf ("/ ");
-		dump_uint64 (dv);
-	    }
-	    
-	    qv = _cairo_uint128_divmod (q[0+s*width], q[1+s*width]).rem;
-	    if (reps == 1)
+	    for (op = 0; op < N_OP; op++)
 	    {
-		printf ("%% ");
-		dump_uint128 (qv);
+		if (!ops[op].valid64 ||
+		    (*ops[op].valid64) (d[0+s*width], d[1+s*width]))
+		{
+		    dv = (*ops[op].s64)(d[0+s*width], d[1+s*width]);
+		    if (reps == 1)
+		    {
+			printf ("s  64 %s ", ops[op].name);
+			dump_int64 (dv);
+			printf ("\n");
+		    }
+		    dv = (*ops[op].u64)(d[0+s*width], d[1+s*width]);
+		    if (reps == 1)
+		    {
+			printf ("u  64 %s ", ops[op].name);
+			dump_uint64 (dv);
+			printf ("\n");
+		    }
+		}
+		if (!ops[op].valid128 ||
+		    (*ops[op].valid128) (q[0+s*width], q[1+s*width]))
+		{
+		    qv = (*ops[op].s128)(q[0+s*width], q[1+s*width]);
+		    if (reps == 1)
+		    {
+			printf ("s 128 %s ", ops[op].name);
+			dump_int128 (qv);
+			printf ("\n");
+		    }
+		    
+		    qv = (*ops[op].u128)(q[0+s*width], q[1+s*width]);
+		    if (reps == 1)
+		    {
+			printf ("u 128 %s ", ops[op].name);
+			dump_uint128 (qv);
+			printf ("\n");
+		    }
+		}
 	    }
-
-	    dv = _cairo_uint64_divmod (d[0+s*width], d[1+s*width]).rem;
 	    if (reps == 1)
-	    {
-		printf ("%% ");
-		dump_uint64 (dv);
-	    }
+		printf ("\n");
 	}
     }
     return 0;

Index: cairo_uint128.c
===================================================================
RCS file: /local/src/CVS/cairo_u128/cairo_uint128.c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- a/cairo_uint128.c	25 May 2004 21:21:52 -0000	1.4
+++ b/cairo_uint128.c	28 May 2004 05:47:16 -0000	1.5
@@ -24,6 +24,8 @@
 
 #include "cairo_uint128.h"
 
+#if !HAVE_UINT64_T || !HAVE_UINT128_T
+
 static const unsigned char top_bit[256] =
 {
     0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
@@ -36,44 +38,22 @@
     8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
 };
[...1010 lines suppressed...]
     return qr;
 }
+    
+const cairo_int128_t
+_cairo_int128_negate (cairo_int128_t a)
+{
+    a.lo = _cairo_uint64_not (a.lo);
+    a.hi = _cairo_uint64_not (a.hi);
+    return _cairo_uint128_add (a, _cairo_uint32_to_uint128 (1));
+}
 
+const cairo_int128_t
+_cairo_int128_not (cairo_int128_t a)
+{
+    a.lo = _cairo_uint64_not (a.lo);
+    a.hi = _cairo_uint64_not (a.hi);
+    return a;
+}
+
+#endif /* !HAVE_UINT128_T */

Index: cairo_uint128.h
===================================================================
RCS file: /local/src/CVS/cairo_u128/cairo_uint128.h,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- a/cairo_uint128.h	25 May 2004 21:21:52 -0000	1.4
+++ b/cairo_uint128.h	28 May 2004 05:47:16 -0000	1.5
@@ -27,122 +27,242 @@
 
 #include <stdint.h>
 
-#if !HAVE_UINT64_T
+/*
+ * 64-bit datatypes.  Two separate implementations, one using
+ * built-in 64-bit signed/unsigned types another implemented
+ * as a pair of 32-bit ints
+ */
 
-#define CAIRO_NUM_IN_UINT64 2
+#if !HAVE_UINT64_T
 
 typedef struct _cairo_uint64 {
-    uint32_t	b[CAIRO_NUM_IN_UINT64];
-} cairo_uint64_t;
-
-extern const cairo_uint64_t
-_cairo_uint32_to_uint64 (uint32_t i);
-
-extern const uint32_t
-_cairo_uint64_to_uint32 (cairo_uint64_t i);
+    uint32_t	lo, hi;
+} cairo_uint64_t, cairo_int64_t;
 
-extern const cairo_uint64_t
-_cairo_uint64_add (cairo_uint64_t a, cairo_uint64_t b);
+const cairo_uint64_t	_cairo_uint32_to_uint64 (uint32_t i);
+#define			_cairo_uint64_to_uint32(a)  ((a).lo)
+const cairo_uint64_t	_cairo_uint64_add (cairo_uint64_t a, cairo_uint64_t b);
+const cairo_uint64_t	_cairo_uint64_sub (cairo_uint64_t a, cairo_uint64_t b);
+const cairo_uint64_t	_cairo_uint64_mul (cairo_uint64_t a, cairo_uint64_t b);
+const cairo_uint64_t	_cairo_uint32x32_64_mul (uint32_t a, uint32_t b);
+const cairo_uint64_t	_cairo_uint64_lsl (cairo_uint64_t a, int shift);
+const cairo_uint64_t	_cairo_uint64_rsl (cairo_uint64_t a, int shift);
+const cairo_uint64_t	_cairo_uint64_rsa (cairo_uint64_t a, int shift);
+const int		_cairo_uint64_lt (cairo_uint64_t a, cairo_uint64_t b);
+const int		_cairo_uint64_eq (cairo_uint64_t a, cairo_uint64_t b);
+const cairo_uint64_t	_cairo_uint64_negate (cairo_uint64_t a);
+#define			_cairo_uint64_negative(a)   (((int32_t) ((a).hi)) < 0)
+const cairo_uint64_t	_cairo_uint64_not (cairo_uint64_t a);
 
-extern const cairo_uint64_t
-_cairo_uint64_sub (cairo_uint64_t a, cairo_uint64_t b);
+#define			_cairo_uint64_to_int64(i)   (i)
+#define			_cairo_int64_to_uint64(i)   (i)
 
-extern const cairo_uint64_t
-_cairo_uint64_mul (cairo_uint64_t a, cairo_uint64_t b);
+const cairo_int64_t	_cairo_int32_to_int64(int32_t i);
+#define			_cairo_int64_to_int32(a)    ((int32_t) _cairo_uint64_to_uint32(a))
+#define			_cairo_int64_add(a,b)	    _cairo_uint64_add (a,b)
+#define			_cairo_int64_sub(a,b)	    _cairo_uint64_sub (a,b)
+#define			_cairo_int64_mul(a,b)	    _cairo_uint64_mul (a,b)
+#define			_cairo_int32x32_64_mul(a,b) _cairo_uint32x32_64_mul ((uint32_t) (a), (uint32_t) (b)))
+const int		_cairo_int64_lt (cairo_uint64_t a, cairo_uint64_t b);
+#define			_cairo_int64_eq(a,b)	    _cairo_uint64_eq (a,b)
+#define			_cairo_int64_lsl(a,b)	    _cairo_uint64_lsl (a,b)
+#define			_cairo_int64_rsl(a,b)	    _cairo_uint64_rsl (a,b)
+#define			_cairo_int64_rsa(a,b)	    _cairo_uint64_rsa (a,b)
+#define			_cairo_int64_negate(a)	    _cairo_uint64_negate(a)
+#define			_cairo_int64_negative(a)    (((int32_t) ((a).hi)) < 0)
+#define			_cairo_int64_not(a)	    _cairo_uint64_not(a)
 
-extern const cairo_uint64_t
-_cairo_uint32x32_64_mul (uint32_t a, uint32_t b);
+#else
 
-extern const cairo_uint64_t
-_cairo_uint64_lsl (cairo_uint64_t a, int shift);
+typedef uint64_t    cairo_uint64_t;
+typedef int64_t	    cairo_int64_t;
 
-extern const cairo_uint64_t
-_cairo_uint64_rsl (cairo_uint64_t a, int shift);
+#define			_cairo_uint32_to_uint64(i)  ((uint64_t) (i))
+#define			_cairo_uint64_to_uint32(i)  ((uint32_t) (i))
+#define			_cairo_uint64_add(a,b)	    ((a) + (b))
+#define			_cairo_uint64_sub(a,b)	    ((a) - (b))
+#define			_cairo_uint64_mul(a,b)	    ((a) * (b))
+#define			_cairo_uint32x32_64_mul(a,b)	((uint64_t) (a) * (b))
+#define			_cairo_uint64_lsl(a,b)	    ((a) << (b))
+#define			_cairo_uint64_rsl(a,b)	    ((uint64_t) (a) >> (b))
+#define			_cairo_uint64_rsa(a,b)	    ((uint64_t) ((int64_t) (a) >> (b)))
+#define			_cairo_uint64_lt(a,b)	    ((a) < (b))
+#define			_cairo_uint64_eq(a,b)	    ((a) == (b))
+#define			_cairo_uint64_negate(a)	    ((uint64_t) -((int64_t) (a)))
+#define			_cairo_uint64_negative(a)   ((int64_t) (a) < 0)
+#define			_cairo_uint64_not(a)	    (~(a))
 
-extern const int
-_cairo_uint64_less (cairo_uint64_t a, cairo_uint64_t b);
+#define			_cairo_uint64_to_int64(i)   ((int64_t) (i))
+#define			_cairo_int64_to_uint64(i)   ((uint64_t) (i))
 
-extern const int
-_cairo_uint64_equal (cairo_uint64_t a, cairo_uint64_t b);
+#define			_cairo_int32_to_int64(i)    ((int64_t) (i))
+#define			_cairo_int64_to_int32(i)    ((int32_t) (i))
+#define			_cairo_int64_add(a,b)	    ((a) + (b))
+#define			_cairo_int64_sub(a,b)	    ((a) - (b))
+#define			_cairo_int64_mul(a,b)	    ((a) * (b))
+#define			_cairo_int32x32_64_mul(a,b) ((int64_t) (a) * (b))
+#define			_cairo_int64_lt(a,b)	    ((a) < (b))
+#define			_cairo_int64_eq(a,b)	    ((a) == (b))
+#define			_cairo_int64_lsl(a,b)	    ((a) << (b))
+#define			_cairo_int64_rsl(a,b)	    ((int64_t) ((uint64_t) (a) >> (b)))
+#define			_cairo_int64_rsa(a,b)	    ((int64_t) (a) >> (b))
+#define			_cairo_int64_negate(a)	    (-(a))
+#define			_cairo_int64_negative(a)    ((a) < 0)
+#define			_cairo_int64_not(a)	    (~(a))
 
-#else
+#endif
 
-typedef uint64_t    cairo_uint64_t;
+/*
+ * 64-bit comparisions derived from lt or eq
+ */
+#define			_cairo_uint64_le(a,b)	    (!_cairo_uint64_gt(a,b))
+#define			_cairo_uint64_ne(a,b)	    (!_cairo_uint64_eq(a,b))
+#define			_cairo_uint64_ge(a,b)	    (!_cairo_uint64_lt(a,b))
+#define			_cairo_uint64_gt(a,b)	    _cairo_uint64_lt(b,a)
 
-#define _cairo_uint32_to_uint64(i)	((uint64_t) (i))
-#define _cairo_uint64_to_uint32(i)	((uint32_t) (i))
-#define _cairo_uint64_add(a,b)		((a) + (b))
-#define _cairo_uint64_sub(a,b)		((a) - (b))
-#define _cairo_uint64_mul(a,b)		((a) * (b))
-#define _cairo_uint32x32_64_mul(a,b)	((uint64_t) (a) * (b))
-#define _cairo_uint64_lsl(a,b)		((a) << (b))
-#define _cairo_uint64_rsl(a,b)		((a) >> (b))
-#define _cairo_uint64_lt(a,b)		((a) < (b))
-#define _cairo_uint64_eq(a,b)		((a) == (b))
+#define			_cairo_int64_le(a,b)	    (!_cairo_int64_gt(a,b))
+#define			_cairo_int64_ne(a,b)	    (!_cairo_int64_eq(a,b))
+#define			_cairo_int64_ge(a,b)	    (!_cairo_int64_lt(a,b))
+#define			_cairo_int64_gt(a,b)	    _cairo_int64_lt(b,a)
 
-#endif
+/*
+ * As the C implementation always computes both, create
+ * a function which returns both for the 'native' type as well
+ */
 
-typedef struct _cairo_quorem64 {
+typedef struct _cairo_uquorem64 {
     cairo_uint64_t	quo;
     cairo_uint64_t	rem;
-} cairo_quorem64_t;
-
-extern const cairo_quorem64_t
-_cairo_uint64_divmod (cairo_uint64_t num, cairo_uint64_t den);
+} cairo_uquorem64_t;
 
-#define _cairo_uint64_gt(a,b) _cairo_uint64_lt(b,a)
-#define _cairo_uint64_le(a,b) (!_cairo_uint64_gt(a,b))
-#define _cairo_uint64_ge(a,b) (!_cairo_uint64_lt(a,b))
-#define _cairo_uint64_ne(a,b) (!_cairo_uint64_eq(a,b))
+typedef struct _cairo_quorem64 {
+    cairo_int64_t	quo;
+    cairo_int64_t	rem;
+} cairo_quorem64_t;
 
-typedef struct cairo_uint128 {
-    cairo_uint64_t	b[2];
-} cairo_uint128_t;
+const cairo_uquorem64_t
+_cairo_uint64_divrem (cairo_uint64_t num, cairo_uint64_t den);
 
-extern const cairo_uint128_t
-_cairo_uint32_to_uint128 (uint32_t i);
+const cairo_quorem64_t
+_cairo_int64_divrem (cairo_int64_t num, cairo_int64_t den);
 
-extern const cairo_uint128_t
-_cairo_uint64_to_uint128 (cairo_uint64_t i);
+/*
+ * 128-bit datatypes.  Again, provide two implementations in
+ * case the machine has a native 128-bit datatype.  GCC supports int128_t
+ * on ia64
+ */
+ 
+#if !HAVE_UINT128_T
 
-extern const cairo_uint64_t
-_cairo_uint128_to_uint64 (cairo_uint128_t i);
+typedef struct cairo_uint128 {
+    cairo_uint64_t	lo, hi;
+} cairo_uint128_t, cairo_int128_t;
 
-extern const uint32_t
-_cairo_uint128_to_uint32 (cairo_uint128_t i);
+const cairo_uint128_t	_cairo_uint32_to_uint128 (uint32_t i);
+const cairo_uint128_t	_cairo_uint64_to_uint128 (cairo_uint64_t i);
+#define			_cairo_uint128_to_uint64(a)	((a).lo)
+#define			_cairo_uint128_to_uint32(a)	_cairo_uint64_to_uint32(_cairo_uint128_to_uint64(a))
+const cairo_uint128_t	_cairo_uint128_add (cairo_uint128_t a, cairo_uint128_t b);
+const cairo_uint128_t	_cairo_uint128_sub (cairo_uint128_t a, cairo_uint128_t b);
+const cairo_uint128_t	_cairo_uint128_mul (cairo_uint128_t a, cairo_uint128_t b);
+const cairo_uint128_t	_cairo_uint64x64_128_mul (cairo_uint64_t a, cairo_uint64_t b);
+const cairo_uint128_t	_cairo_uint128_lsl (cairo_uint128_t a, int shift);
+const cairo_uint128_t	_cairo_uint128_rsl (cairo_uint128_t a, int shift);
+const cairo_uint128_t	_cairo_uint128_rsa (cairo_uint128_t a, int shift);
+const int		_cairo_uint128_lt (cairo_uint128_t a, cairo_uint128_t b);
+const int		_cairo_uint128_eq (cairo_uint128_t a, cairo_uint128_t b);
+const cairo_uint128_t	_cairo_uint128_negate (cairo_uint128_t a);
+#define			_cairo_uint128_negative(a)  (_cairo_uint64_negative(a.hi))
+const cairo_uint128_t	_cairo_uint128_not (cairo_uint128_t a);
 
-extern const cairo_uint128_t
-_cairo_uint128_add (cairo_uint128_t a, cairo_uint128_t b);
+#define			_cairo_uint128_to_int128_(i)	(i)
+#define			_cairo_int128_to_uint128(i)	(i)
 
-extern const cairo_uint128_t
-_cairo_uint128_sub (cairo_uint128_t a, cairo_uint128_t b);
+const cairo_int128_t	_cairo_int32_to_int128 (int32_t i);
+const cairo_int128_t	_cairo_int64_to_int128 (cairo_int64_t i);
+#define			_cairo_int128_to_int64(a)   ((cairo_int64_t) (a).lo);
+#define			_cairo_int128_to_int32(a)   _cairo_int64_to_int32(_cairo_int128_to_int64(a))
+#define			_cairo_int128_add(a,b)	    _cairo_uint128_add(a,b)
+#define			_cairo_int128_sub(a,b)	    _cairo_uint128_sub(a,b)
+#define			_cairo_int128_mul(a,b)	    _cairo_uint128_mul(a,b)
+#define			_cairo_int64x64_128_mul(a,b)_cairo_uint64x64_128_mul ((cairo_uint64_t) (a), (cairo_uint64_t) (b)))
+#define			_cairo_int128_lsl(a,b)	    _cairo_uint128_lsl(a,b)
+#define			_cairo_int128_rsl(a,b)	    _cairo_uint128_rsl(a,b)
+#define			_cairo_int128_rsa(a,b)	    _cairo_uint128_rsa(a,b)
+const int		_cairo_int128_lt (cairo_int128_t a, cairo_int128_t b);
+#define			_cairo_int128_eq(a,b)	    _cairo_uint128_eq (a,b)
+#define			_cairo_int128_negate(a)	    _cairo_uint128_negate(a)
+#define			_cairo_int128_negative(a)   (_cairo_uint128_negative(a))
+#define			_cairo_int128_not(a)	    _cairo_uint128_not(a)
 
-extern const cairo_uint128_t
-_cairo_uint128_mul (cairo_uint128_t a, cairo_uint128_t b);
+#else	/* !HAVE_UINT128_T */
 
-extern const cairo_uint128_t
-_cairo_uint128_lsl (cairo_uint128_t a, int shift);
+typedef uint128_t	cairo_uint128_t;
+typedef int128_t	cairo_int128_t;
 
-extern const cairo_uint128_t
-_cairo_uint128_rsl (cairo_uint128_t a, int shift);
+#define			_cairo_uint32_to_uint128(i) ((uint128_t) (i))
+#define			_cairo_uint64_to_uint128(i) ((uint128_t) (i))
+#define			_cairo_uint128_to_uint64(i) ((uint64_t) (i))
+#define			_cairo_uint128_to_uint32(i) ((uint32_t) (i))
+#define			_cairo_uint128_add(a,b)	    ((a) + (b))
+#define			_cairo_uint128_sub(a,b)	    ((a) - (b))
+#define			_cairo_uint128_mul(a,b)	    ((a) * (b))
+#define			_cairo_uint64x64_128_mul(a,b)	((uint128_t) (a) * (b))
+#define			_cairo_uint128_lsl(a,b)	    ((a) << (b))
+#define			_cairo_uint128_rsl(a,b)	    ((uint128_t) (a) >> (b))
+#define			_cairo_uint128_rsa(a,b)	    ((uint128_t) ((int128_t) (a) >> (b)))
+#define			_cairo_uint128_lt(a,b)	    ((a) < (b))
+#define			_cairo_uint128_eq(a,b)	    ((a) == (b))
+#define			_cairo_uint128_negate(a)    ((uint128_t) -((int128_t) (a)))
+#define			_cairo_uint128_negative(a)  ((int128_t) (a) < 0)
+#define			_cairo_uint128_not(a)	    (~(a))
 
-extern const int
-_cairo_uint128_lt (cairo_uint128_t a, cairo_uint128_t b);
+#define			_cairo_uint128_to_int128(i) ((int128_t) (i))
+#define			_cairo_int128_to_uint128(i) ((uint128_t) (i))
 
-extern const int
-_cairo_uint128_eq (cairo_uint128_t a, cairo_uint128_t b);
+#define			_cairo_int32_to_int128(i)   ((int128_t) (i))
+#define			_cairo_int64_to_int128(i)   ((int128_t) (i))
+#define			_cairo_int128_to_int64(i)   ((int64_t) (i))
+#define			_cairo_int128_to_int32(i)   ((int32_t) (i))
+#define			_cairo_int128_add(a,b)	    ((a) + (b))
+#define			_cairo_int128_sub(a,b)	    ((a) - (b))
+#define			_cairo_int128_mul(a,b)	    ((a) * (b))
+#define			_cairo_int64x64_128_mul(a,b) ((int128_t) (a) * (b))
+#define			_cairo_int128_lt(a,b)	    ((a) < (b))
+#define			_cairo_int128_eq(a,b)	    ((a) == (b))
+#define			_cairo_int128_lsl(a,b)	    ((a) << (b))
+#define			_cairo_int128_rsl(a,b)	    ((int128_t) ((uint128_t) (a) >> (b)))
+#define			_cairo_int128_rsa(a,b)	    ((int128_t) (a) >> (b))
+#define			_cairo_int128_negate(a)	    (-(a))
+#define			_cairo_int128_negative(a)   ((a) < 0)
+#define			_cairo_int128_not(a)	    (~(a))
 
-#define _cairo_uint128_gt(a,b) _cairo_uint128_lt(b,a)
-#define _cairo_uint128_le(a,b) (!_cairo_uint128_gt(a,b))
-#define _cairo_uint128_ge(a,b) (!_cairo_uint128_lt(a,b))
-#define _cairo_uint128_ne(a,b) (!_cairo_uint128_eq(a,b))
+#endif	/* HAVE_UINT128_T */
 
-typedef struct _cairo_quorem128 {
+typedef struct _cairo_uquorem128 {
     cairo_uint128_t	quo;
     cairo_uint128_t	rem;
+} cairo_uquorem128_t;
+
+typedef struct _cairo_quorem128 {
+    cairo_int128_t	quo;
+    cairo_int128_t	rem;
 } cairo_quorem128_t;
 
-extern const cairo_quorem128_t
-_cairo_uint128_divmod (cairo_uint128_t num, cairo_uint128_t den);
+const cairo_uquorem128_t
+_cairo_uint128_divrem (cairo_uint128_t num, cairo_uint128_t den);
+
+const cairo_quorem128_t
+_cairo_int128_divrem (cairo_int128_t num, cairo_int128_t den);
+
+#define			_cairo_uint128_le(a,b)	    (!_cairo_uint128_gt(a,b))
+#define			_cairo_uint128_ne(a,b)	    (!_cairo_uint128_eq(a,b))
+#define			_cairo_uint128_ge(a,b)	    (!_cairo_uint128_lt(a,b))
+#define			_cairo_uint128_gt(a,b)	    _cairo_uint128_lt(b,a)
+
+#define			_cairo_int128_le(a,b)	    (!_cairo_int128_gt(a,b))
+#define			_cairo_int128_ne(a,b)	    (!_cairo_int128_eq(a,b))
+#define			_cairo_int128_ge(a,b)	    (!_cairo_int128_lt(a,b))
+#define			_cairo_int128_gt(a,b)	    _cairo_int128_lt(b,a)
 
 #endif /* CAIRO_UINT128_H */

Index: checkdata.5c
===================================================================
RCS file: /local/src/CVS/cairo_u128/checkdata.5c,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- a/checkdata.5c	25 May 2004 21:21:52 -0000	1.4
+++ b/checkdata.5c	28 May 2004 05:47:16 -0000	1.5
@@ -11,46 +11,103 @@
     return x;
 }
 
-int prod(int[*] q)
+int mask(int bits) {
+    return (1 << bits) - 1;
+}
+
+int unsigned (int n, int bits)
 {
-    int	p = 1;
-    for (int i = 0; i < dim(q); i++)
-	p *= q[i];
-    return p;
+    return n & mask (bits);
 }
 
-int sum(int[*] q)
+int signed(int n, int bits)
 {
-    int	p = 0;
-    for (int i = 0; i < dim(q); i++)
-	p += q[i];
-    return p;
+    n &= mask (bits);
+    if ((n & (1 << (bits - 1))) != 0)
+	n |= -1 << bits;
+    return n;
 }
 
 void op (string name, int (int, int, int) f, int[2] n)
 {
-    void dump (int bits)
+    void dump (int bits, bool s)
     {
 	try {
-	    int	mask = (1 << bits) - 1;
-	    printf ("%s %x\n", name, f (n[0] & mask, n[1] & mask, bits) & mask);
+	    int a, b;
+	    if (s)
+	    {
+		a = signed (n[0], bits);
+		b = signed (n[1], bits);
+	    }
+	    else
+	    {
+		a = unsigned (n[0], bits);
+		b = unsigned (n[1], bits);
+	    }
+	    
+	    int v = f (a, b, bits);
+	    
+	    if (s)
+		v = signed (v, bits);
+	    else
+		v = unsigned (v, bits);
+	    
+	    printf ("%s %3d %s %x\n",
+		    s ? "s" : "u",
+		    bits,
+		    name, v);
 	} catch divide_by_zero (string msg, real a, real b) {
 	    return;
 	}
     }
-    dump (128);
-    dump (64);
+    dump (64, true);
+    dump (64, false);
+    dump (128, true);
+    dump (128, false);
+}
+
+int div(int a, int b) {
+    int	d = abs (a) // abs (b);
+    if ((a < 0) != (b < 0))
+	d = -d;
+    return d;
+}
+
+int rem(int a, int b) {
+    int r = abs (a) % abs (b);
+    if (a < 0)
+	r = -r;
+    return r;
 }
 
 for (;;)
 {
     int[*]  n = readnums();
-    printf ("%x\n%x\n", n[0], n[1]);
+    for (int bits = 64; bits <= 128; bits <<= 1)
+	for (int f = 0; f < 2; f++)
+	    printf ("%s %3d %x %x\n",
+		    f == 0 ? "s" : "u",
+		    bits,
+		    (f == 0 ? signed : unsigned) (n[0], bits),
+		    (f == 0 ? signed : unsigned) (n[1], bits));
+    printf ("\n");
     op ("+", int func (int a, int b, int bits) { return a + b; }, n);
     op ("-", int func (int a, int b, int bits) { return a - b; }, n);
     op ("*", int func (int a, int b, int bits) { return a * b; }, n);
-    op (">>", int func (int a, int b, int bits) { return a >> (b % bits); }, n);
-    op ("<<", int func (int a, int b, int bits) { return a << (b % bits); }, n);
-    op ("/", int func (int a, int b, int bits) { return a // b; }, n);
-    op ("%", int func (int a, int b, int bits) { return a % b; }, n);
+    op (">>", int func (int a, int b, int bits) { 
+	return unsigned (a, bits) >> (b % bits);
+    }, n);
+    op (">>>", int func (int a, int b, int bits) { 
+	return signed (a, bits) >> (b % bits);
+    }, n);
+    op ("<<", int func (int a, int b, int bits) { return a << (b & (bits-1)); }, n);
+    op ("/", int func (int a, int b, int bits) { return div(a, b); }, n);
+    op ("%", int func (int a, int b, int bits) { return rem(a, b); }, n);
+    op ("<",  int func (int a, int b, int bits) { return a <  b ? 1 : 0; }, n);
+    op ("<=", int func (int a, int b, int bits) { return a <= b ? 1 : 0; }, n);
+    op ("==", int func (int a, int b, int bits) { return a == b ? 1 : 0; }, n);
+    op ("!=", int func (int a, int b, int bits) { return a != b ? 1 : 0; }, n);
+    op (">=", int func (int a, int b, int bits) { return a >= b ? 1 : 0; }, n);
+    op (">",  int func (int a, int b, int bits) { return a >  b ? 1 : 0; }, n);
+    printf ("\n");
 }

Index: makedata.5c
===================================================================
RCS file: /local/src/CVS/cairo_u128/makedata.5c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -d -r1.2 -r1.3
--- a/makedata.5c	25 May 2004 21:21:52 -0000	1.2
+++ b/makedata.5c	28 May 2004 05:47:16 -0000	1.3
@@ -5,7 +5,9 @@
 for (int n = 0; n < nsets; n++)
 {
     for (int i = 0; i < 2; i++)
-	printf ("%x ", PRNG::randbits(128));
+	printf ("%x ", 
+		PRNG::randbits(PRNG::randint(126) + 1) *
+		(PRNG::randint(2) * 2 - 1));
     printf ("\n");
 }
 	




More information about the Commit mailing list