Return to expd.bc CVS log

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

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

1.1       root        1: define m() {
                      2: 
                      3:        j = f(12,  1/0.125, 1);
                      4:        j = f(128, 1/16, 1);
                      5:        j = f(256, 1/(16*256), 1);
                      6:        j = f(256, 1/(16*256*256), 1);
                      7:        j = f(256, 1/(16*256*256*256), 1);
                      8: 
                      9:        j = f(12,  1/0.125, 0);
                     10:        j = f(128, 1/16, 0);
                     11:        j = f(256, 1/(16*256), 0);
                     12:        j = f(256, 1/(16*256*256), 0);
                     13:        j = f(256, 1/(16*256*256*256), 0);
                     14: }
                     15: 
                     16: define f(m, n, p) {
                     17:        auto    j, g;
                     18: 
                     19:        for (i = 1; i < m; i++) {
                     20:                j = i * n;
                     21:                if (p == 1) g = p(j);
                     22:                if (p == 0) g = n(j);
                     23:        }
                     24: }
                     25: 
                     26: define p(x) {
                     27:        auto    j;
                     28: 
                     29:        y = x / b;
                     30:        s = scale;
                     31:        scale = 0;
                     32:        t = y / 1;
                     33:        scale = s;
                     34:        e = t + 1;
                     35:        f = y - t;
                     36:        j = f * b;
                     37:        f = e(j) / 2;
                     38: 
                     39:        obase = 16;
                     40:        ibase = 16;
                     41:        f = f * 100000000000000;
                     42: 
                     43:        s = scale;
                     44:        scale = 0;
                     45: 
                     46:        r = f % 1;
                     47:        f = f / 1;
                     48:        if (r  * 2 >= 1) f += 1;
                     49: 
                     50:        if (f == 100000000000000) {
                     51:                f /= 2;
                     52:                e += 1;
                     53:        }
                     54: 
                     55:        e += 80;
                     56:        f -= 80000000000000;
                     57: 
                     58:        d = e * 80000000000000 + f;
                     59:        d
                     60: 
                     61:        scale = s;
                     62:        ibase = A;
                     63: }
                     64: 
                     65: define n(x) {
                     66:        auto    j;
                     67: 
                     68:        y = x / b;
                     69:        s = scale;
                     70:        scale = 0;
                     71:        t = y / 1;
                     72:        scale = s;
                     73:        e = -t;
                     74:        f = y - t;
                     75:        j = f * b;
                     76:        f = 1 / e(j);
                     77: 
                     78:        obase = 16;
                     79:        ibase = 16;
                     80:        f = f * 100000000000000;
                     81: 
                     82:        s = scale;
                     83:        scale = 0;
                     84: 
                     85:        r = f % 1;
                     86:        f = f / 1;
                     87:        if (r  * 2 >= 1) f += 1;
                     88: 
                     89:        if (f == 100000000000000) {
                     90:                f /= 2;
                     91:                e += 1;
                     92:        }
                     93: 
                     94:        e += 80;
                     95:        f -= 80000000000000;
                     96: 
                     97:        d = e * 80000000000000 + f;
                     98:        d
                     99: 
                    100:        scale = s;
                    101:        ibase = A;
                    102: }
                    103: 
                    104: scale = 40;
                    105: b = l(2);
                    106: j = m();
                    107: quit

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