Return to factor.c CVS log

Up to [MW Coherent from dump] / coherent / a / usr / src / sample

Annotation of coherent/a/usr/src/sample/factor.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Factor prints out the prime factorization of numbers.
        !             3:  * If there are arguments, it factors them.
        !             4:  * If there are no arguments, it reads stdin until
        !             5:  * either EOF or the number zero or a non-numeric
        !             6:  * non-white-space character.  Since factor does all of
        !             7:  * its calculations in double format, the largest number
        !             8:  * which can be handled is quite large.
        !             9:  */
        !            10: #include <stdio.h>
        !            11: #include <math.h>
        !            12: #include <ctype.h>
        !            13: 
        !            14: 
        !            15: #define        NUL     '\0'
        !            16: #define        ERROR   0x10    /* largest input base */
        !            17: #define        MAXNUM  200     /* max number of chars in number */
        !            18: 
        !            19: 
        !            20: main(argc, argv)
        !            21: int            argc;
        !            22: register char  *argv[];
        !            23: {
        !            24:        register char   *chp;
        !            25:        double          n;
        !            26:        double          atod();
        !            27:        char            *getnum();
        !            28: 
        !            29:        if (argc != 1)
        !            30:                while ((chp=*++argv) != NULL &&
        !            31:                        (n=atod(chp)) != 0)
        !            32:                        factor(n);
        !            33:        else
        !            34:                while ((chp=getnum()) != NULL &&
        !            35:                        (n=atod(chp)) != 0)
        !            36:                        factor(n);
        !            37:        return (0);
        !            38: }
        !            39: 
        !            40: 
        !            41: die(str)
        !            42: char   *str;
        !            43: {
        !            44:        fprintf(stderr, "%r\n", &str);
        !            45:        exit(1);
        !            46: }
        !            47: 
        !            48: usage()
        !            49: {
        !            50:        die("Usage: factor [number number ...]");
        !            51: }
        !            52: 
        !            53: 
        !            54: char   *
        !            55: getnum()
        !            56: {
        !            57:        register char   *chp,
        !            58:                        ch;
        !            59:        static char     res[MAXNUM+1];
        !            60: 
        !            61:        do {
        !            62:                ch = getchar();
        !            63:        } while (isascii(ch) && isspace(ch));
        !            64:        if (!isascii(ch) || todigit(ch) == ERROR)
        !            65:                return (NULL);
        !            66:        for (chp=res; isascii(ch) && !isspace(ch);
        !            67:                ch=getchar())
        !            68:                if (chp < &res[MAXNUM])
        !            69:                        *chp++ = ch;
        !            70:        if (chp >= &res[MAXNUM])
        !            71:                die("number too big");
        !            72:        *chp++ = NUL;
        !            73:        return (res);
        !            74: }
        !            75: 
        !            76: 
        !            77: /*
        !            78:  * Factor is the routine that actually factors the double `n'.
        !            79:  * It writes the prime factors to standard output.
        !            80:  */
        !            81: factor(n)
        !            82: double n;
        !            83: {
        !            84:        double          temp,
        !            85:                        limit,
        !            86:                        try;
        !            87: 
        !            88:        while (n > 1 && modf(n/2, &temp) == 0) {
        !            89:                printf("2 ");
        !            90:                n = temp;
        !            91:        }
        !            92:        limit = sqrt(n);
        !            93:        for (try=3; try <= limit; try += 2) {
        !            94:                if (modf(n/try, &temp) != 0)
        !            95:                        continue;
        !            96:                do {
        !            97:                        printf("%.0f ", try);
        !            98:                        n = temp;
        !            99:                } while (modf(n/try, &temp) == 0);
        !           100:                limit = sqrt(n);
        !           101:        }
        !           102:        if (n > 1)
        !           103:                printf("%.0f", n);
        !           104:        putchar('\n');
        !           105: }

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