Return to logd.bc CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / cci / libM

Annotation of 43BSDTahoe/cci/libM/logd.bc, revision 1.1.1.1

1.1       root        1: define b() {
                      2:        auto    i, r, d;
                      3: 
                      4:        for (i = 0; i < 255; i++) {
                      5:                d = 0.5 + ((i + 1) / 512);
                      6:                r = 1 / d;
                      7:                a[i] = r * 65536;
                      8:                b[i] = l(d);
                      9:        }
                     10:        a[255] = 1 * 65536;
                     11:        b[255] = 0;
                     12: 
                     13:        scale = 40;
                     14:        for (i = 0; i < 256; i++) a[i];
                     15:        for (i = 0; i < 256; i++) b[i];
                     16: }
                     17: 
                     18: define d() {
                     19:        auto    i, r, d;
                     20: 
                     21:        for (i = 0; i < 256; i++) {
                     22:                d = 1 - (i / 65536);
                     23:                c[i] = 1 / (65536 - i);
                     24:                d[i] = l(d);
                     25:        }
                     26: 
                     27:        scale = 40;
                     28:        for (i = 0; i < 256; i++) c[i];
                     29:        for (i = 0; i < 256; i++) d[i];
                     30: }
                     31: 
                     32: define f() {
                     33:        auto    i, r, d;
                     34: 
                     35:        for (i = 0; i < 256; i++) {
                     36:                d = 1 + i / 256;
                     37:                r = 1 / d;
                     38:                e[i] = r * 32768;
                     39:                f[i] = l(d);
                     40:        }
                     41: 
                     42:        scale = 40;
                     43:        for (i = 0; i < 256; i++) e[i];
                     44:        for (i = 0; i < 256; i++) f[i];
                     45: }
                     46: 
                     47: define g() {
                     48:        auto    i, r, d;
                     49: 
                     50:        for (i = 0; i < 128; i++) {
                     51:                d = 1 + (i / 32768);
                     52:                g[i] = 1 / (32768 + i);
                     53:                h[i] = l(d);
                     54:        }
                     55: 
                     56:        scale = 40;
                     57:        for (i = 0; i < 128; i++) g[i];
                     58:        for (i = 0; i < 128; i++) h[i];
                     59: }
                     60: 
                     61: define h() {
                     62:        auto    i;
                     63: 
                     64:        for (i = 0; i < 129; i++) {
                     65:                i[i] = (i-128) * 0.69314718055994530941723212145817656807550013;
                     66:        }
                     67: 
                     68:        for (i = 129; i < 256; i++) {
                     69:                i[i] = (i-129) * 0.69314718055994530941723212145817656807550013;
                     70:        }
                     71: 
                     72:        scale = 40;
                     73:        for (i = 0; i < 256; i++) i[i];
                     74: }
                     75: 
                     76: define m() {
                     77:        auto    j;
                     78: 
                     79:        j = b();
                     80:        j = d();
                     81:        j = f();
                     82:        j = g();
                     83:        j = h();
                     84: }
                     85: 
                     86: scale = 40;
                     87: j = m();
                     88: quit

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