Return to range.c CVS log

Up to [CSRG BSD Unix] / 43BSD / usr.lib / libF77

Annotation of 43BSD/usr.lib/libF77/range.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Copyright (c) 1980 Regents of the University of California.
                      3:  * All rights reserved.  The Berkeley software License Agreement
                      4:  * specifies the terms and conditions for redistribution.
                      5:  *
                      6:  *     @(#)range.c     5.2     6/7/85
                      7:  *
                      8:  * routines to return extreme values
                      9:  * VERY MACHINE DEPENDENT
                     10:  */
                     11: 
                     12: union fi
                     13: {      float   f;
                     14:        long    i;
                     15: } ;
                     16: 
                     17: union dj
                     18: {      double  d;
                     19:        long    j[2];
                     20: } ;
                     21: 
                     22: float
                     23: flmax_()
                     24: {
                     25:        union fi n;
                     26: #if    pdp11
                     27:        n.i = 0x7fffffffL;
                     28: #else  pdp11
                     29: #if    vax
                     30:        n.i = 0xffff7fff;
                     31: #else  vax
                     32:        UNKNOWN MACHINE!
                     33: #endif vax
                     34: #endif pdp11
                     35:        return(n.f);
                     36: }
                     37: 
                     38: double
                     39: dflmax_()
                     40: {
                     41:        union dj n;
                     42: #if    pdp11
                     43:        n.j[0] = 0x7fffffffL;
                     44:        n.j[1] = 0xffffffffL;
                     45: #else  pdp11
                     46: #if    vax
                     47:        n.j[0] = 0xffff7fff;
                     48:        n.j[1] = 0xffffffff;
                     49: #else  vax
                     50:        UNKNOWN MACHINE!
                     51: #endif vax
                     52: #endif pdp11
                     53:        return(n.d);
                     54: }
                     55: 
                     56: float
                     57: flmin_()
                     58: {
                     59:        union fi n;
                     60: #if    pdp11
                     61:        n.i = 0x00800000L;
                     62: #else  pdp11
                     63: #if    vax
                     64:        n.i = 0x00000080;
                     65: #else  vax
                     66:        UNKNOWN MACHINE!
                     67: #endif vax
                     68: #endif pdp11
                     69:        return(n.f);
                     70: }
                     71: 
                     72: double
                     73: dflmin_()
                     74: {
                     75:        union dj n;
                     76: #if    pdp11
                     77:        n.j[0] = 0x00800000L;
                     78:        n.j[1] = 0;
                     79: #else  pdp11
                     80: #if    vax
                     81:        n.j[0] = 0x00000080;
                     82:        n.j[1] = 0;
                     83: #else  vax
                     84:        UNKNOWN MACHINE!
                     85: #endif vax
                     86: #endif pdp11
                     87:        return(n.d);
                     88: }
                     89: 
                     90: long int
                     91: inmax_()
                     92: {
                     93:        return(0x7fffffffL);
                     94: }
                     95: 
                     96: 
                     97: float
                     98: ffrac_()
                     99: {
                    100:        union fi n;
                    101: #if    pdp11
                    102:        n.i = 0x35000000L;
                    103: #else  pdp11
                    104: #if    vax
                    105:        n.i = 0x00003500;
                    106: #else  vax
                    107:        UNKNOWN MACHINE!
                    108: #endif vax
                    109: #endif pdp11
                    110:        return(n.f);
                    111: }
                    112: 
                    113: double
                    114: dffrac_()
                    115: {
                    116:        union dj n;
                    117: #if    pdp11
                    118:        n.j[0] = 0x25000000L;
                    119:        n.j[1] = 0;
                    120: #else  pdp11
                    121: #if    vax
                    122:        n.j[0] = 0x00002500;
                    123:        n.j[1] = 0;
                    124: #else  vax
                    125:        UNKNOWN MACHINE!
                    126: #endif vax
                    127: #endif pdp11
                    128:        return(n.d);
                    129: }

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