summaryrefslogtreecommitdiffstats
path: root/src/isaac_rand
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/isaac_rand/isaac64.c119
-rw-r--r--src/isaac_rand/isaac64.h41
-rw-r--r--src/isaac_rand/isaac_rand.c169
-rw-r--r--src/isaac_rand/isaac_rand.h52
-rw-r--r--src/isaac_rand/isaac_standard.h60
5 files changed, 441 insertions, 0 deletions
diff --git a/src/isaac_rand/isaac64.c b/src/isaac_rand/isaac64.c
new file mode 100644
index 0000000..3e4203b
--- /dev/null
+++ b/src/isaac_rand/isaac64.c
@@ -0,0 +1,119 @@
+/*
+------------------------------------------------------------------------------
+isaac64.c: My random number generator for 64-bit machines.
+By Bob Jenkins, 1996. Public Domain.
+------------------------------------------------------------------------------
+*/
+#ifndef STANDARD
+#include "isaac_standard.h"
+#endif
+#ifndef ISAAC64
+#include "isaac64.h"
+#endif
+
+
+#define ind(mm,x) (*(ub8 *)((ub1 *)(mm) + ((x) & ((RANDSIZ-1)<<3))))
+#define rngstep(mix,a,b,mm,m,m2,r,x) \
+{ \
+ x = *m; \
+ a = (mix) + *(m2++); \
+ *(m++) = y = ind(mm,x) + a + b; \
+ *(r++) = b = ind(mm,y>>RANDSIZL) + x; \
+}
+
+void isaac64(rand64ctx *ctx)
+{
+ register ub8 a,b,x,y,*m,*mm,*m2,*r,*mend;
+ mm=ctx->mm; r=ctx->randrsl;
+ a = ctx->aa; b = ctx->bb + (++ctx->cc);
+ for (m = mm, mend = m2 = m+(RANDSIZ/2); m<mend; )
+ {
+ rngstep(~(a^(a<<21)), a, b, mm, m, m2, r, x);
+ rngstep( a^(a>>5) , a, b, mm, m, m2, r, x);
+ rngstep( a^(a<<12) , a, b, mm, m, m2, r, x);
+ rngstep( a^(a>>33) , a, b, mm, m, m2, r, x);
+ }
+ for (m2 = mm; m2<mend; )
+ {
+ rngstep(~(a^(a<<21)), a, b, mm, m, m2, r, x);
+ rngstep( a^(a>>5) , a, b, mm, m, m2, r, x);
+ rngstep( a^(a<<12) , a, b, mm, m, m2, r, x);
+ rngstep( a^(a>>33) , a, b, mm, m, m2, r, x);
+ }
+ ctx->bb = b; ctx->aa = a;
+}
+
+#define mix(a,b,c,d,e,f,g,h) \
+{ \
+ a-=e; f^=h>>9; h+=a; \
+ b-=f; g^=a<<9; a+=b; \
+ c-=g; h^=b>>23; b+=c; \
+ d-=h; a^=c<<15; c+=d; \
+ e-=a; b^=d>>14; d+=e; \
+ f-=b; c^=e<<20; e+=f; \
+ g-=c; d^=f>>17; f+=g; \
+ h-=d; e^=g<<14; g+=h; \
+}
+
+void rand64init(rand64ctx *ctx, word flag)
+{
+ word i;
+ ub8 a,b,c,d,e,f,g,h;
+ ub8 *mm, *randrsl;
+ ctx->aa = ctx->bb = ctx->cc = (ub8)0;
+ mm=ctx->mm;
+ randrsl=ctx->randrsl;
+ a=b=c=d=e=f=g=h=0x9e3779b97f4a7c13LL; /* the golden ratio */
+
+ for (i=0; i<4; ++i) /* scramble it */
+ {
+ mix(a,b,c,d,e,f,g,h);
+ }
+
+ for (i=0; i<RANDSIZ; i+=8) /* fill in mm[] with messy stuff */
+ {
+ if (flag) /* use all the information in the seed */
+ {
+ a+=randrsl[i ]; b+=randrsl[i+1]; c+=randrsl[i+2]; d+=randrsl[i+3];
+ e+=randrsl[i+4]; f+=randrsl[i+5]; g+=randrsl[i+6]; h+=randrsl[i+7];
+ }
+ mix(a,b,c,d,e,f,g,h);
+ mm[i ]=a; mm[i+1]=b; mm[i+2]=c; mm[i+3]=d;
+ mm[i+4]=e; mm[i+5]=f; mm[i+6]=g; mm[i+7]=h;
+ }
+
+ if (flag)
+ { /* do a second pass to make all of the seed affect all of mm */
+ for (i=0; i<RANDSIZ; i+=8)
+ {
+ a+=mm[i ]; b+=mm[i+1]; c+=mm[i+2]; d+=mm[i+3];
+ e+=mm[i+4]; f+=mm[i+5]; g+=mm[i+6]; h+=mm[i+7];
+ mix(a,b,c,d,e,f,g,h);
+ mm[i ]=a; mm[i+1]=b; mm[i+2]=c; mm[i+3]=d;
+ mm[i+4]=e; mm[i+5]=f; mm[i+6]=g; mm[i+7]=h;
+ }
+ }
+
+ isaac64(ctx); /* fill in the first set of results */
+ ctx->randcnt=RANDSIZ; /* prepare to use the first set of results */
+}
+
+#ifdef NEVER
+int main()
+{
+ ub8 i,j;
+ rand64ctx ctx;
+ ctx.aa=ctx.bb=ctx.cc=(ub8)0;
+ for (i=0; i<RANDSIZ; ++i) ctx.mm[i]=(ub8)0;
+ rand64init(&ctx, TRUE);
+ for (i=0; i<2; ++i)
+ {
+ isaac64(&ctx);
+ for (j=0; j<RANDSIZ; ++j)
+ {
+ printf("%.8lx%.8lx",(ub4)(ctx.randrsl[j]>>32),(ub4)ctx.randrsl[j]);
+ if ((j&3)==3) printf("\n");
+ }
+ }
+}
+#endif
diff --git a/src/isaac_rand/isaac64.h b/src/isaac_rand/isaac64.h
new file mode 100644
index 0000000..e2ab55b
--- /dev/null
+++ b/src/isaac_rand/isaac64.h
@@ -0,0 +1,41 @@
+/*
+------------------------------------------------------------------------------
+isaac64.h: definitions for a random number generator
+Bob Jenkins, 1996, Public Domain
+------------------------------------------------------------------------------
+*/
+#ifndef ISAAC64
+#define ISAAC64
+
+#include "isaac_standard.h"
+
+struct rand64ctx
+{
+ ub8 randrsl[RANDSIZ], randcnt;
+ ub8 mm[RANDSIZ];
+ ub8 aa, bb, cc;
+};
+typedef struct rand64ctx rand64ctx;
+
+/*
+------------------------------------------------------------------------------
+ If (flag==TRUE), then use the contents of randrsl[0..255] as the seed.
+------------------------------------------------------------------------------
+*/
+void rand64init(rand64ctx *r, word flag);
+
+void isaac64(rand64ctx *ctx);
+
+
+/*
+------------------------------------------------------------------------------
+ Call rand64() to retrieve a single 64-bit random value
+------------------------------------------------------------------------------
+*/
+#define isaac64_rand() \
+ (!(r)->randcnt-- ? \
+ (isaac64(r), (r)->randcnt=RANDSIZ-1, (r)->randrsl[(r)->>randcnt]) : \
+ (r)->randrsl[(r)->randcnt])
+
+#endif /* ISAAC64 */
+
diff --git a/src/isaac_rand/isaac_rand.c b/src/isaac_rand/isaac_rand.c
new file mode 100644
index 0000000..c9220e0
--- /dev/null
+++ b/src/isaac_rand/isaac_rand.c
@@ -0,0 +1,169 @@
+/*
+------------------------------------------------------------------------------
+rand.c: By Bob Jenkins. My random number generator, ISAAC. Public Domain.
+MODIFIED:
+ 960327: Creation (addition of randinit, really)
+ 970719: use context, not global variables, for internal state
+ 980324: added main (ifdef'ed out), also rearranged randinit()
+ 010626: Note that this is public domain
+------------------------------------------------------------------------------
+*/
+#ifndef STANDARD
+#include "isaac_standard.h"
+#endif
+#ifndef RAND
+#include "isaac_rand.h"
+#endif
+
+
+#define ind(mm,x) (*(ub4 *)((ub1 *)(mm) + ((x) & ((RANDSIZ-1)<<2))))
+#define rngstep(mix,a,b,mm,m,m2,r,x) \
+{ \
+ x = *m; \
+ a = (a^(mix)) + *(m2++); \
+ *(m++) = y = ind(mm,x) + a + b; \
+ *(r++) = b = ind(mm,y>>RANDSIZL) + x; \
+}
+
+void isaac(ctx)
+randctx *ctx;
+{
+ register ub4 a,b,x,y,*m,*mm,*m2,*r,*mend;
+ mm=ctx->randmem;
+ r=ctx->randrsl;
+ a = ctx->randa;
+ b = ctx->randb + (++ctx->randc);
+ for (m = mm, mend = m2 = m+(RANDSIZ/2); m<mend; )
+ {
+ rngstep( a<<13, a, b, mm, m, m2, r, x);
+ rngstep( a>>6 , a, b, mm, m, m2, r, x);
+ rngstep( a<<2 , a, b, mm, m, m2, r, x);
+ rngstep( a>>16, a, b, mm, m, m2, r, x);
+ }
+ for (m2 = mm; m2<mend; )
+ {
+ rngstep( a<<13, a, b, mm, m, m2, r, x);
+ rngstep( a>>6 , a, b, mm, m, m2, r, x);
+ rngstep( a<<2 , a, b, mm, m, m2, r, x);
+ rngstep( a>>16, a, b, mm, m, m2, r, x);
+ }
+ ctx->randb = b; ctx->randa = a;
+}
+
+
+#define mix(a,b,c,d,e,f,g,h) \
+{ \
+ a^=b<<11; d+=a; b+=c; \
+ b^=c>>2; e+=b; c+=d; \
+ c^=d<<8; f+=c; d+=e; \
+ d^=e>>16; g+=d; e+=f; \
+ e^=f<<10; h+=e; f+=g; \
+ f^=g>>4; a+=f; g+=h; \
+ g^=h<<8; b+=g; h+=a; \
+ h^=a>>9; c+=h; a+=b; \
+}
+
+/* if (flag==TRUE), then use the contents of randrsl[] to initialize mm[]. */
+void randinit(ctx, flag)
+randctx *ctx;
+word flag;
+{
+ word i;
+ ub4 a,b,c,d,e,f,g,h;
+ ub4 *m,*r;
+ ctx->randa = ctx->randb = ctx->randc = 0;
+ m=ctx->randmem;
+ r=ctx->randrsl;
+ a=b=c=d=e=f=g=h=0x9e3779b9; /* the golden ratio */
+
+ for (i=0; i<4; ++i) /* scramble it */
+ {
+ mix(a,b,c,d,e,f,g,h);
+ }
+
+ if (flag)
+ {
+ /* initialize using the contents of r[] as the seed */
+ for (i=0; i<RANDSIZ; i+=8)
+ {
+ a+=r[i ];
+ b+=r[i+1];
+ c+=r[i+2];
+ d+=r[i+3];
+ e+=r[i+4];
+ f+=r[i+5];
+ g+=r[i+6];
+ h+=r[i+7];
+ mix(a,b,c,d,e,f,g,h);
+ m[i ]=a;
+ m[i+1]=b;
+ m[i+2]=c;
+ m[i+3]=d;
+ m[i+4]=e;
+ m[i+5]=f;
+ m[i+6]=g;
+ m[i+7]=h;
+ }
+ /* do a second pass to make all of the seed affect all of m */
+ for (i=0; i<RANDSIZ; i+=8)
+ {
+ a+=m[i ];
+ b+=m[i+1];
+ c+=m[i+2];
+ d+=m[i+3];
+ e+=m[i+4];
+ f+=m[i+5];
+ g+=m[i+6];
+ h+=m[i+7];
+ mix(a,b,c,d,e,f,g,h);
+ m[i ]=a;
+ m[i+1]=b;
+ m[i+2]=c;
+ m[i+3]=d;
+ m[i+4]=e;
+ m[i+5]=f;
+ m[i+6]=g;
+ m[i+7]=h;
+ }
+ }
+ else
+ {
+ /* fill in m[] with messy stuff */
+ for (i=0; i<RANDSIZ; i+=8)
+ {
+ mix(a,b,c,d,e,f,g,h);
+ m[i ]=a;
+ m[i+1]=b;
+ m[i+2]=c;
+ m[i+3]=d;
+ m[i+4]=e;
+ m[i+5]=f;
+ m[i+6]=g;
+ m[i+7]=h;
+ }
+ }
+
+ isaac(ctx); /* fill in the first set of results */
+ ctx->randcnt=RANDSIZ; /* prepare to use the first set of results */
+}
+
+
+#ifdef NEVER
+int main()
+{
+ ub4 i,j;
+ randctx ctx;
+ ctx.randa=ctx.randb=ctx.randc=(ub4)0;
+ for (i=0; i<256; ++i) ctx.randrsl[i]=(ub4)0;
+ randinit(&ctx, TRUE);
+ for (i=0; i<2; ++i)
+ {
+ isaac(&ctx);
+ for (j=0; j<256; ++j)
+ {
+ printf("%.8lx",ctx.randrsl[j]);
+ if ((j&7)==7) printf("\n");
+ }
+ }
+}
+#endif
diff --git a/src/isaac_rand/isaac_rand.h b/src/isaac_rand/isaac_rand.h
new file mode 100644
index 0000000..167a2fd
--- /dev/null
+++ b/src/isaac_rand/isaac_rand.h
@@ -0,0 +1,52 @@
+/*
+------------------------------------------------------------------------------
+rand.h: definitions for a random number generator
+By Bob Jenkins, 1996, Public Domain
+MODIFIED:
+ 960327: Creation (addition of randinit, really)
+ 970719: use context, not global variables, for internal state
+ 980324: renamed seed to flag
+ 980605: recommend RANDSIZL=4 for noncryptography.
+ 010626: note this is public domain
+------------------------------------------------------------------------------
+*/
+#ifndef RAND
+#define RAND
+
+#include "isaac_standard.h"
+
+/* context of random number generator */
+struct randctx
+{
+ ub4 randcnt;
+ ub4 randrsl[RANDSIZ];
+ ub4 randmem[RANDSIZ];
+ ub4 randa;
+ ub4 randb;
+ ub4 randc;
+};
+typedef struct randctx randctx;
+
+/*
+------------------------------------------------------------------------------
+ If (flag==TRUE), then use the contents of randrsl[0..RANDSIZ-1] as the seed.
+------------------------------------------------------------------------------
+*/
+void randinit(/*_ randctx *r, word flag _*/);
+
+void isaac(/*_ randctx *r _*/);
+
+
+/*
+------------------------------------------------------------------------------
+ Call rand(/o_ randctx *r _o/) to retrieve a single 32-bit random value
+------------------------------------------------------------------------------
+*/
+#define isaac_rand(r) \
+ (!(r)->randcnt-- ? \
+ (isaac(r), (r)->randcnt=RANDSIZ-1, (r)->randrsl[(r)->randcnt]) : \
+ (r)->randrsl[(r)->randcnt])
+
+#endif /* RAND */
+
+
diff --git a/src/isaac_rand/isaac_standard.h b/src/isaac_rand/isaac_standard.h
new file mode 100644
index 0000000..5323d3f
--- /dev/null
+++ b/src/isaac_rand/isaac_standard.h
@@ -0,0 +1,60 @@
+/*
+------------------------------------------------------------------------------
+Standard definitions and types, Bob Jenkins
+------------------------------------------------------------------------------
+*/
+#ifndef STANDARD
+# define STANDARD
+# ifndef STDIO
+# include <stdio.h>
+# define STDIO
+# endif
+# ifndef STDDEF
+# include <stddef.h>
+# define STDDEF
+# endif
+typedef unsigned long long ub8;
+#define UB8MAXVAL 0xffffffffffffffffLL
+#define UB8BITS 64
+typedef signed long long sb8;
+#define SB8MAXVAL 0x7fffffffffffffffLL
+typedef unsigned long int ub4; /* unsigned 4-byte quantities */
+#define UB4MAXVAL 0xffffffff
+typedef signed long int sb4;
+#define UB4BITS 32
+#define SB4MAXVAL 0x7fffffff
+typedef unsigned short int ub2;
+#define UB2MAXVAL 0xffff
+#define UB2BITS 16
+typedef signed short int sb2;
+#define SB2MAXVAL 0x7fff
+typedef unsigned char ub1;
+#define UB1MAXVAL 0xff
+#define UB1BITS 8
+typedef signed char sb1; /* signed 1-byte quantities */
+#define SB1MAXVAL 0x7f
+typedef int word; /* fastest type available */
+
+#define bis(target,mask) ((target) |= (mask))
+#define bic(target,mask) ((target) &= ~(mask))
+#define bit(target,mask) ((target) & (mask))
+#ifndef min
+# define min(a,b) (((a)<(b)) ? (a) : (b))
+#endif /* min */
+#ifndef max
+# define max(a,b) (((a)<(b)) ? (b) : (a))
+#endif /* max */
+#ifndef align
+# define align(a) (((ub4)a+(sizeof(void *)-1))&(~(sizeof(void *)-1)))
+#endif /* align */
+#ifndef abs
+# define abs(a) (((a)>0) ? (a) : -(a))
+#endif
+#define TRUE 1
+#define FALSE 0
+#define SUCCESS 0 /* 1 on VAX */
+
+#define RANDSIZL (8) /* I recommend 8 for crypto, 4 for simulations */
+#define RANDSIZ (1<<RANDSIZL)
+
+#endif /* STANDARD */
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-04 01:01:02 +0000