Return to math.p CVS log

Up to [CSRG BSD Unix] / 43BSDReno / pgrm / pascal / tstpx / src

Annotation of 43BSDReno/pgrm/pascal/tstpx/src/math.p, revision 1.1.1.1

1.1       root        1: program math(input,output);
                      2: 
                      3: label  1;
                      4: 
                      5: type
                      6: chrint=-120..120;
                      7: sint=-1000..1000;
                      8: ray=array[1..2] of record
                      9:   first :real;
                     10:   second :alfa;
                     11:   end;
                     12: 
                     13: var
                     14: i :chrint;
                     15: j :sint;
                     16: k :integer;
                     17: l, m :real;
                     18: ary :ray;
                     19: 
                     20: procedure skip;
                     21: 
                     22: begin
                     23: goto 1;
                     24: end;
                     25: 
                     26: 
                     27: begin
                     28: j:=5;
                     29: k:=10;
                     30: l:=15.0;
                     31: i:=j;
                     32: i:=k;
                     33: j:=k;
                     34: k:=j;
                     35: l:=j;
                     36: l:=k;
                     37: i:=10;
                     38: j:=1000;
                     39: k:=100000;
                     40: l:=1.24e+16;
                     41: ary[1].first:=50.2;
                     42: ary[1].second:='oh boy';
                     43: m:=j+j;
                     44: m:=k+k;
                     45: m:=l+l;
                     46: m:=j+k;
                     47: m:=k+j;
                     48: m:=j+l;
                     49: m:=l+j;
                     50: m:=l+k;
                     51: m:=k+l;
                     52: m:=j-j;
                     53: m:=k-k;
                     54: m:=l-l;
                     55: m:=j-k;
                     56: m:=k-j;
                     57: m:=j-l;
                     58: m:=l-j;
                     59: m:=l-k;
                     60: m:=k-l;
                     61: m:=j*j;
                     62: m:=k/k*k;
                     63: m:=l*l;
                     64: m:=j*k;
                     65: m:=k*j;
                     66: m:=j*l;
                     67: m:=l*j;
                     68: m:=l*k;
                     69: m:=k*l;
                     70: m:=j/j;
                     71: m:=ary[1].first/l;
                     72: m:=j/k;
                     73: m:=k/j;
                     74: m:=j/l;
                     75: m:=l/j;
                     76: m:=l/k;
                     77: m:=k/l;
                     78: m:=j div j;
                     79: m:=k div k;
                     80: m:=j div k;
                     81: m:=k div j;
                     82: m:=j mod j;
                     83: m:=k mod k;
                     84: m:=j mod k;
                     85: m:=k mod j;
                     86: m:=-j;
                     87: m:=-k;
                     88: m:=-l;
                     89: m:=abs(-j)+abs(k)+abs(-l);
                     90: m:=abs(j)+abs(-k)+abs(l);
                     91: if (k=k) and
                     92:    (j<k) and
                     93:    (k>=j) and
                     94:    (l=l) and
                     95:    (j<=l) and
                     96:    (k<>l) and
                     97:    (l>j) and
                     98:    (l>k) and
                     99:    (ary[1].second=ary[1].second) then
                    100: writeln((ary[1].second):7,'it works !!!');
                    101: skip;
                    102: writeln('error');
                    103: 1:
                    104: ary[2]:=ary[i-9];
                    105: writeln('hex k = ',k:1 hex,'   octal k = ',k oct);
                    106: writeln('octal j = ',j:1 oct,'   hex j = ',j hex);
                    107: i:=1;
                    108: end.

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