Return to factor.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin

Annotation of coherent/d/bin/factor.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Factor prints out the prime factorization of numbers.  If there are
                      3:  * any arguments, then it factors these.  If there are no arguments,
                      4:  * then it reads stdin until either EOF or the number zero or a non-numeric
                      5:  * non-white-space character.  Since factor does all of its calculations
                      6:  * in double format, the largest number which can be handled is quite
                      7:  * large.
                      8:  */
                      9: #include <stdio.h>
                     10: #include <math.h>
                     11: #include <ctype.h>
                     12: 
                     13: 
                     14: #define        NUL     '\0'
                     15: #define        ERROR   0x10                    /* largest input base */
                     16: #define        MAXNUM  200                     /* max number of chars in number */
                     17: 
                     18: 
                     19: main(argc, argv)
                     20: int            argc;
                     21: register char  *argv[];
                     22: {
                     23:        register char   *chp;
                     24:        double          n;
                     25:        double          atod();
                     26:        char            *getnum();
                     27: 
                     28:        if (argc != 1)
                     29:                while ((chp=*++argv) != NULL && (n=atod(chp)) != 0)
                     30:                        factor(n);
                     31:        else
                     32:                while ((chp=getnum()) != NULL && (n=atod(chp)) != 0)
                     33:                        factor(n);
                     34:        return (0);
                     35: }
                     36: 
                     37: 
                     38: die(str)
                     39: char   *str;
                     40: {
                     41:        fprintf(stderr, "%r\n", &str);
                     42:        exit(1);
                     43: }
                     44: 
                     45: usage()
                     46: {
                     47:        die("usage: factor [number number ...]");
                     48: }
                     49: 
                     50: 
                     51: char   *
                     52: getnum()
                     53: {
                     54:        register char   *chp,
                     55:                        ch;
                     56:        static char     res[MAXNUM+1];
                     57: 
                     58:        do {
                     59:                ch = getchar();
                     60:        } while (isascii(ch) && isspace(ch));
                     61:        if (!isascii(ch) || todigit(ch) == ERROR)
                     62:                return (NULL);
                     63:        for (chp=res; isascii(ch) && !isspace(ch); ch=getchar())
                     64:                if (chp < &res[MAXNUM])
                     65:                        *chp++ = ch;
                     66:        if (chp >= &res[MAXNUM])
                     67:                die("Number too big");
                     68:        *chp++ = NUL;
                     69:        return (res);
                     70: }
                     71: 
                     72: 
                     73: /*
                     74:  * Atod converts the string `num' to a double and returns the value.
                     75:  * Note, that if there is a non-digit in the string, or if there is
                     76:  * an overflow, then it exits with an appropriate error message.
                     77:  * Also note that atod accepts leading zero for octal and leading
                     78:  * 0x for hexidecimal, and that in the latter case, a-f and A-F are
                     79:  * both accepted as digits.
                     80:  */
                     81: double
                     82: atod(num)
                     83: char   *num;
                     84: {
                     85:        register char   *str;
                     86:        register int    i;
                     87:        double          res     = 0,
                     88:                        base    = 10;
                     89: 
                     90:        str = num;
                     91:        i = *str++;
                     92:        if (i == '0')
                     93:                if ((i=*str++) == 'x') {
                     94:                        i = *str++;
                     95:                        base = 0x10;
                     96:                } else
                     97:                        base = 010;
                     98:        for (; i != '\0'; i=*str++) {
                     99:                i = todigit(i);
                    100:                if (i >= base)
                    101:                        die("bad number `%s'", num);
                    102:                res = res * base + i;
                    103:                if (res+1 == res)
                    104:                        die("Number too big `%s'", num);
                    105:        }
                    106:        return (res);
                    107: }
                    108: 
                    109: 
                    110: /*
                    111:  * Todigit converts the char `ch' to an integer equivalent, assuming
                    112:  * that `ch' is a digit or `a'-`f' or `A'-`F'.  If this is not true,
                    113:  * then it returns ERROR.
                    114:  */
                    115: todigit(ch)
                    116: register int   ch;
                    117: {
                    118:        if (!isascii(ch))
                    119:                return (ERROR);
                    120:        if (isdigit(ch))
                    121:                return (ch - '0' + 0);
                    122:        if (isupper(ch))
                    123:                ch = tolower(ch);
                    124:        if ('a' <= ch && ch <= 'f')
                    125:                return (ch - 'a' + 0xa);
                    126:        return (ERROR);
                    127: }
                    128: 
                    129: 
                    130: /*
                    131:  * Factor is the routine that actually factors the double `n'.
                    132:  * It writes the prime factors to standard output.
                    133:  */
                    134: factor(n)
                    135: double n;
                    136: {
                    137:        double          temp,
                    138:                        limit,
                    139:                        try;
                    140: 
                    141:        while (n > 1 && modf(n/2, &temp) == 0) {
                    142:                printf("2 ");
                    143:                n = temp;
                    144:        }
                    145:        limit = sqrt(n);
                    146:        for (try=3; try <= limit; try += 2) {
                    147:                if (modf(n/try, &temp) != 0)
                    148:                        continue;
                    149:                do {
                    150:                        printf("%.0f ", try);
                    151:                        n = temp;
                    152:                } while (modf(n/try, &temp) == 0);
                    153:                limit = sqrt(n);
                    154:        }
                    155:        if (n > 1)
                    156:                printf("%.0f", n);
                    157:        putchar('\n');
                    158: }

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