Return to msma.c CVS log

Up to [MW Coherent from dump] / coherent / d / usr / lib / libmp

Annotation of coherent/d/usr/lib/libmp/msma.c, revision 1.1.1.1

1.1       root        1: #include "mprec.h"
                      2: #include <assert.h>
                      3: 
                      4: 
                      5: /*
                      6:  *     Msma takes the mint pointed to by "to" and adds to it (in place)
                      7:  *     the product of the following :
                      8:  *             1. the mint pointed to by "from".
                      9:  *             2. the int "fac" (it is assumed that 0 <= fac < 2 * BASE).
                     10:  *             3. BASE raised to the "shift" power.
                     11:  *     Note that it is assumed that the length of "to" is big enough to
                     12:  *     hold the result.
                     13:  *     It is also assumed that "from" and "to" are distinct.
                     14:  */
                     15: 
                     16: void
                     17: msma(from, fac, shift, to)
                     18: mint *from, *to;
                     19: int fac;
                     20: unsigned shift;
                     21: {
                     22:        register int carry;
                     23:        register char *fp, *tp;
                     24:        register unsigned count;
                     25:        int mifl;
                     26: 
                     27:        assert(0 <= fac && fac < 2 * BASE);
                     28: 
                     29:        /* general case needs fac != 0, so handle fac == 0 */
                     30:        if (fac == 0)
                     31:                return;
                     32: 
                     33:        /* find out sign of "from" */
                     34:        mifl = ispos(from);
                     35: 
                     36:        /* do the multiply assuming "from" is positive */
                     37:        fp = from->val;
                     38:        tp = to->val + shift;
                     39:        carry = 0;
                     40:        count = from->len;
                     41:        if (!mifl)
                     42:                --count;
                     43:        assert(tp + count <= to->val + to->len);
                     44:        while (count-- != 0) {
                     45:                carry += *tp + *fp++ * fac;
                     46:                *tp++ = carry % BASE;
                     47:                carry >>= L2BASE;
                     48:        }
                     49: 
                     50:        /* propogate carry or borrow */
                     51:        count = to->val + to->len - tp;
                     52:        if (!mifl)
                     53:                carry -= fac;
                     54:        while (count-- != 0 && carry != 0) {
                     55:                carry += *tp + BASE;
                     56:                *tp++ = carry % BASE;
                     57:                carry = (carry >> L2BASE) - 1;
                     58:        }
                     59: }

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