simplifications: basic arithmetic functions

Author: minad

mp_add_d.c

@@ -6,9 +6,7 @@
 /* single digit addition */
 mp_err mp_add_d(const mp_int *a, mp_digit b, mp_int *c)
 {
-   mp_err     err;
-   int ix, oldused;
-   mp_digit *tmpa, *tmpc;
+   int oldused;
 
    /* fast path for a == c */
    if (a == c) {
@@ -27,13 +25,15 @@ mp_err mp_add_d(const mp_int *a, mp_digit b, mp_int *c)
 
    /* grow c as required */
    if (c->alloc < (a->used + 1)) {
+      mp_err err;
       if ((err = mp_grow(c, a->used + 1)) != MP_OKAY) {
          return err;
       }
    }
 
    /* if a is negative and |a| >= b, call c = |a| - b */
    if ((a->sign == MP_NEG) && ((a->used > 1) || (a->dp[0] >= b))) {
+      mp_err err;
       mp_int a_ = *a;
       /* temporarily fix sign of a */
       a_.sign = MP_ZPOS;
@@ -53,49 +53,34 @@ mp_err mp_add_d(const mp_int *a, mp_digit b, mp_int *c)
    /* old number of used digits in c */
    oldused = c->used;
 
-   /* source alias */
-   tmpa    = a->dp;
-
-   /* destination alias */
-   tmpc    = c->dp;
-
    /* if a is positive */
    if (a->sign == MP_ZPOS) {
       /* add digits, mu is carry */
+      int i;
       mp_digit mu = b;
-      for (ix = 0; ix < a->used; ix++) {
-         *tmpc   = *tmpa++ + mu;
-         mu      = *tmpc >> MP_DIGIT_BIT;
-         *tmpc++ &= MP_MASK;
+      for (i = 0; i < a->used; i++) {
+         c->dp[i] = a->dp[i] + mu;
+         mu = c->dp[i] >> MP_DIGIT_BIT;
+         c->dp[i] &= MP_MASK;
       }
       /* set final carry */
-      ix++;
-      *tmpc++  = mu;
+      c->dp[i] = mu;
 
       /* setup size */
       c->used = a->used + 1;
    } else {
       /* a was negative and |a| < b */
-      c->used  = 1;
+      c->used = 1;
 
       /* the result is a single digit */
-      if (a->used == 1) {
-         *tmpc++  =  b - a->dp[0];
-      } else {
-         *tmpc++  =  b;
-      }
-
-      /* setup count so the clearing of oldused
-       * can fall through correctly
-       */
-      ix       = 1;
+      c->dp[0] = (a->used == 1) ? b - a->dp[0] : b;
    }
 
    /* sign always positive */
    c->sign = MP_ZPOS;
 
    /* now zero to oldused */
-   MP_ZERO_DIGITS(tmpc, oldused - ix);
+   MP_ZERO_DIGITS(c->dp + c->used, oldused - c->used);
    mp_clamp(c);
 
    return MP_OKAY;

mp_div_2.c

@@ -6,12 +6,11 @@
 /* b = a/2 */
 mp_err mp_div_2(const mp_int *a, mp_int *b)
 {
-   int     x, oldused;
-   mp_digit r, rr, *tmpa, *tmpb;
-   mp_err err;
+   int x, oldused;
+   mp_digit r;
 
-   /* copy */
    if (b->alloc < a->used) {
+      mp_err err;
       if ((err = mp_grow(b, a->used)) != MP_OKAY) {
          return err;
       }
@@ -20,20 +19,14 @@ mp_err mp_div_2(const mp_int *a, mp_int *b)
    oldused = b->used;
    b->used = a->used;
 
-   /* source alias */
-   tmpa = a->dp + b->used - 1;
-
-   /* dest alias */
-   tmpb = b->dp + b->used - 1;
-
    /* carry */
    r = 0;
-   for (x = b->used - 1; x >= 0; x--) {
+   for (x = b->used; x --> 0;) {
       /* get the carry for the next iteration */
-      rr = *tmpa & 1u;
+      mp_digit rr = a->dp[x] & 1u;
 
       /* shift the current digit, add in carry and store */
-      *tmpb-- = (*tmpa-- >> 1) | (r << (MP_DIGIT_BIT - 1));
+      b->dp[x] = (a->dp[x] >> 1) | (r << (MP_DIGIT_BIT - 1));
 
       /* forward carry to next iteration */
       r = rr;

mp_div_2d.c

@@ -6,23 +6,16 @@
 /* shift right by a certain bit count (store quotient in c, optional remainder in d) */
 mp_err mp_div_2d(const mp_int *a, int b, mp_int *c, mp_int *d)
 {
-   mp_digit D, r, rr;
-   int     x;
    mp_err err;
 
-   /* if the shift count is <= 0 then we do no work */
-   if (b <= 0) {
-      err = mp_copy(a, c);
-      if (d != NULL) {
-         mp_zero(d);
-      }
-      return err;
+   if (b < 0) {
+      return MP_VAL;
    }
 
-   /* copy */
    if ((err = mp_copy(a, c)) != MP_OKAY) {
       return err;
    }
+
    /* 'a' should not be used after here - it might be the same as d */
 
    /* get the remainder */
@@ -38,28 +31,25 @@ mp_err mp_div_2d(const mp_int *a, int b, mp_int *c, mp_int *d)
    }
 
    /* shift any bit count < MP_DIGIT_BIT */
-   D = (mp_digit)(b % MP_DIGIT_BIT);
-   if (D != 0u) {
-      mp_digit *tmpc, mask, shift;
+   b %= MP_DIGIT_BIT;
+   if (b != 0u) {
+      int x;
+      mp_digit r, mask, shift;
 
       /* mask */
-      mask = ((mp_digit)1 << D) - 1uL;
+      mask = ((mp_digit)1 << b) - 1uL;
 
       /* shift for lsb */
-      shift = (mp_digit)MP_DIGIT_BIT - D;
-
-      /* alias */
-      tmpc = c->dp + (c->used - 1);
+      shift = (mp_digit)(MP_DIGIT_BIT - b);
 
       /* carry */
       r = 0;
-      for (x = c->used - 1; x >= 0; x--) {
+      for (x = c->used; x --> 0;) {
          /* get the lower  bits of this word in a temp */
-         rr = *tmpc & mask;
+         mp_digit rr = c->dp[x] & mask;
 
          /* shift the current word and mix in the carry bits from the previous word */
-         *tmpc = (*tmpc >> D) | (r << shift);
-         --tmpc;
+         c->dp[x] = (c->dp[x] >> b) | (r << shift);
 
          /* set the carry to the carry bits of the current word found above */
          r = rr;

mp_div_d.c

@@ -8,7 +8,6 @@ mp_err mp_div_d(const mp_int *a, mp_digit b, mp_int *c, mp_digit *d)
 {
    mp_int  q;
    mp_word w;
-   mp_digit t;
    mp_err err;
    int ix;
 
@@ -56,14 +55,12 @@ mp_err mp_div_d(const mp_int *a, mp_digit b, mp_int *c, mp_digit *d)
    q.used = a->used;
    q.sign = a->sign;
    w = 0;
-   for (ix = a->used - 1; ix >= 0; ix--) {
+   for (ix = a->used; ix --> 0;) {
+      mp_digit t = 0;
       w = (w << (mp_word)MP_DIGIT_BIT) | (mp_word)a->dp[ix];
-
       if (w >= b) {
          t = (mp_digit)(w / b);
          w -= (mp_word)t * (mp_word)b;
-      } else {
-         t = 0;
       }
       q.dp[ix] = t;
    }
@@ -78,7 +75,7 @@ mp_err mp_div_d(const mp_int *a, mp_digit b, mp_int *c, mp_digit *d)
    }
    mp_clear(&q);
 
-   return err;
+   return MP_OKAY;
 }
 
 #endif

mp_mul.c

@@ -7,8 +7,8 @@
 mp_err mp_mul(const mp_int *a, const mp_int *b, mp_int *c)
 {
    mp_err err;
-   int min_len = MP_MIN(a->used, b->used),
-       max_len = MP_MAX(a->used, b->used),
+   int min = MP_MIN(a->used, b->used),
+       max = MP_MAX(a->used, b->used),
        digs = a->used + b->used + 1;
    mp_sign neg = (a->sign == b->sign) ? MP_ZPOS : MP_NEG;
 
@@ -20,16 +20,16 @@ mp_err mp_mul(const mp_int *a, const mp_int *b, mp_int *c)
         * Using it to cut the input into slices small enough for s_mp_mul_digs_fast
         * was actually slower on the author's machine, but YMMV.
         */
-       (min_len >= MP_KARATSUBA_MUL_CUTOFF) &&
-       ((max_len / 2) >= MP_KARATSUBA_MUL_CUTOFF) &&
+       (min >= MP_KARATSUBA_MUL_CUTOFF) &&
+       ((max / 2) >= MP_KARATSUBA_MUL_CUTOFF) &&
        /* Not much effect was observed below a ratio of 1:2, but again: YMMV. */
-       (max_len >= (2 * min_len))) {
+       (max >= (2 * min))) {
       err = s_mp_balance_mul(a,b,c);
    } else if (MP_HAS(S_MP_TOOM_MUL) &&
-              (min_len >= MP_TOOM_MUL_CUTOFF)) {
+              (min >= MP_TOOM_MUL_CUTOFF)) {
       err = s_mp_toom_mul(a, b, c);
    } else if (MP_HAS(S_MP_KARATSUBA_MUL) &&
-              (min_len >= MP_KARATSUBA_MUL_CUTOFF)) {
+              (min >= MP_KARATSUBA_MUL_CUTOFF)) {
       err = s_mp_karatsuba_mul(a, b, c);
    } else if (MP_HAS(S_MP_MUL_DIGS_FAST) &&
               /* can we use the fast multiplier?
@@ -39,7 +39,7 @@ mp_err mp_mul(const mp_int *a, const mp_int *b, mp_int *c)
                * digits won't affect carry propagation
                */
               (digs < MP_WARRAY) &&
-              (min_len <= MP_MAXFAST)) {
+              (min <= MP_MAXFAST)) {
       err = s_mp_mul_digs_fast(a, b, c, digs);
    } else if (MP_HAS(S_MP_MUL_DIGS)) {
       err = s_mp_mul_digs(a, b, c, digs);

mp_mul_2.c

@@ -6,11 +6,12 @@
 /* b = a*2 */
 mp_err mp_mul_2(const mp_int *a, mp_int *b)
 {
-   int     x, oldused;
-   mp_err err;
+   int x, oldused;
+   mp_digit r;
 
    /* grow to accomodate result */
    if (b->alloc < (a->used + 1)) {
+      mp_err err;
       if ((err = mp_grow(b, a->used + 1)) != MP_OKAY) {
          return err;
       }
@@ -19,45 +20,35 @@ mp_err mp_mul_2(const mp_int *a, mp_int *b)
    oldused = b->used;
    b->used = a->used;
 
-   {
-      mp_digit r, rr, *tmpa, *tmpb;
+   /* carry */
+   r = 0;
+   for (x = 0; x < a->used; x++) {
 
-      /* alias for source */
-      tmpa = a->dp;
-
-      /* alias for dest */
-      tmpb = b->dp;
-
-      /* carry */
-      r = 0;
-      for (x = 0; x < a->used; x++) {
+      /* get what will be the *next* carry bit from the
+       * MSB of the current digit
+       */
+      mp_digit rr = a->dp[x] >> (mp_digit)(MP_DIGIT_BIT - 1);
 
-         /* get what will be the *next* carry bit from the
-          * MSB of the current digit
-          */
-         rr = *tmpa >> (mp_digit)(MP_DIGIT_BIT - 1);
+      /* now shift up this digit, add in the carry [from the previous] */
+      b->dp[x] = ((a->dp[x] << 1uL) | r) & MP_MASK;
 
-         /* now shift up this digit, add in the carry [from the previous] */
-         *tmpb++ = ((*tmpa++ << 1uL) | r) & MP_MASK;
+      /* copy the carry that would be from the source
+       * digit into the next iteration
+       */
+      r = rr;
+   }
 
-         /* copy the carry that would be from the source
-          * digit into the next iteration
-          */
-         r = rr;
-      }
+   /* new leading digit? */
+   if (r != 0u) {
+      /* add a MSB which is always 1 at this point */
+      b->dp[b->used++] = 1;
+   }
 
-      /* new leading digit? */
-      if (r != 0u) {
-         /* add a MSB which is always 1 at this point */
-         *tmpb = 1;
-         ++(b->used);
-      }
+   /* now zero any excess digits on the destination
+    * that we didn't write to
+    */
+   MP_ZERO_DIGITS(b->dp + b->used, oldused - b->used);
 
-      /* now zero any excess digits on the destination
-       * that we didn't write to
-       */
-      MP_ZERO_DIGITS(b->dp + b->used, oldused - b->used);
-   }
    b->sign = a->sign;
    return MP_OKAY;
 }