Return to rand.c CVS log

Up to [Research Unix] / researchv9 / libc / gen

Annotation of researchv9/libc/gen/rand.c, revision 1.1

1.1     ! root        1: #define        LENG    17
        !             2: static
        !             3: long   ary[LENG] =
        !             4: {
        !             5:        0x4B14EA50L,
        !             6:        0x53C4A8E0L,
        !             7:        0x67B1FA98L,
        !             8:        0x9CFB3BB5L,
        !             9:        0x18761AF1L,
        !            10:        0x7970CD66L,
        !            11:        0xDBAFE136L,
        !            12:        0x3C31FC3EL,
        !            13:        0x697B37DEL,
        !            14:        0x07BC568BL,
        !            15:        0xCAFD3967L,
        !            16:        0xA8F48722L,
        !            17:        0x4AB26824L,
        !            18:        0xA479EE47L,
        !            19:        0x5C7246E2L,
        !            20:        0x954BF297L,
        !            21:        0x20A713ADL,
        !            22: };
        !            23: static
        !            24: int    i1 = 0;
        !            25: static
        !            26: int    i2 = 12;
        !            27: 
        !            28: srand(seed)
        !            29: {
        !            30:        register i, j;
        !            31: 
        !            32:        for(i = 0; i < LENG; i++) {
        !            33:                ary[i] = 0x55555555L;
        !            34:                if(seed & 1)
        !            35:                        ary[i] = 0xCCCCCCCCL;
        !            36:                if(seed & 0x8000)
        !            37:                        ary[i] ^= 0xF0F0F0F0L;
        !            38:                seed >>= 1;
        !            39:        }
        !            40:        i1 = 0;
        !            41:        i2 = 12;
        !            42:        for(i = 1; i < 32; i += i)
        !            43:        do {
        !            44:                j = rand();
        !            45:                ary[i1] += ary[i1] >> i;
        !            46:                ary[i2] += ary[i2] << i;
        !            47:        } while (i1);
        !            48: }
        !            49: 
        !            50: rand()
        !            51: {
        !            52: 
        !            53:        if(++i1 >= LENG)
        !            54:                i1 = 0;
        !            55:        if(++i2 >= LENG)
        !            56:                i2 = 0;
        !            57:        ary[i1] += ary[i2];
        !            58:        return((ary[i1] >> 15) & 0x7FFF);
        !            59: }
        !            60: 
        !            61: long
        !            62: lrand()
        !            63: {
        !            64: 
        !            65:        if(++i1 >= LENG)
        !            66:                i1 = 0;
        !            67:        if(++i2 >= LENG)
        !            68:                i2 = 0;
        !            69:        ary[i1] += ary[i2];
        !            70:        return(ary[i1] & 0x7FFFFFFFL);
        !            71: }
        !            72: 
        !            73: double
        !            74: frand()
        !            75: {
        !            76: 
        !            77:        if(++i1 >= LENG)
        !            78:                i1 = 0;
        !            79:        if(++i2 >= LENG)
        !            80:                i2 = 0;
        !            81:        ary[i1] += ary[i2];
        !            82:        return((ary[i1] & 0x7FFFFFFFL) / 2.147483648e9);
        !            83: }
        !            84: 
        !            85: nrand(n)
        !            86: {
        !            87:        register long slop = 0x7FFFFFFFL % n, v;
        !            88: 
        !            89:        do{
        !            90:                if(++i1 >= LENG)
        !            91:                        i1 = 0;
        !            92:                if(++i2 >= LENG)
        !            93:                        i2 = 0;
        !            94:                ary[i1] += ary[i2];
        !            95:                v = ary[i1] & 0x7FFFFFFFL;
        !            96:        }while(v <= slop);
        !            97:        return(v % n);
        !            98: }
        !            99: 
        !           100: Srand(c1, c2, carray, clen)
        !           101:        int *c1, *c2, *carray, *clen;
        !           102: {
        !           103:        register i, j;
        !           104: 
        !           105:        i = *c1; *c1 = i1; i1 = i;
        !           106:        i = *c2; *c2 = i2; i2 = i;
        !           107:        *clen = LENG;
        !           108:        for(i = 0; i < LENG; i++)
        !           109:        {
        !           110:                j = carray[i]; carray[i] = ary[i]; ary[i] = j;
        !           111:        }
        !           112: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.