X-Git-Url: https://git.distorted.org.uk/u/mdw/catacomb/blobdiff_plain/ba6e6b64033b1f9de49feccb5c9cd438354481f7..0f00dc4c8eb47e67bc0f148c2dd109f73a451e0a:/math/gf-gcd.c

diff --git a/math/gf-gcd.c b/math/gf-gcd.c
new file mode 100644
index 0000000..f81aac7
--- /dev/null
+++ b/math/gf-gcd.c
@@ -0,0 +1,261 @@
+/* -*-c-*-
+ *
+ * Euclidian algorithm on binary polynomials
+ *
+ * (c) 2004 Straylight/Edgeware
+ */
+
+/*----- Licensing notice --------------------------------------------------*
+ *
+ * This file is part of Catacomb.
+ *
+ * Catacomb is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Library General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * Catacomb is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with Catacomb; if not, write to the Free
+ * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ */
+
+/*----- Header files ------------------------------------------------------*/
+
+#include "gf.h"
+
+/*----- Main code ---------------------------------------------------------*/
+
+/* --- @gf_gcd@ --- *
+ *
+ * Arguments:	@mp **gcd, **xx, **yy@ = where to write the results
+ *		@mp *a, *b@ = sources (must be nonzero)
+ *
+ *
+ * Returns:	---
+ *
+ * Use:		Calculates @gcd(a, b)@, and two numbers @x@ and @y@ such that
+ *		@ax + by = gcd(a, b)@.  This is useful for computing modular
+ *		inverses.
+ */
+
+void gf_gcd(mp **gcd, mp **xx, mp **yy, mp *a, mp *b)
+{
+  mp *x = MP_ONE, *X = MP_ZERO;
+  mp *y = MP_ZERO, *Y = MP_ONE;
+  mp *u, *v;
+  mp *q = MP_NEW, *t, *spare = MP_NEW;
+  unsigned f = 0;
+
+#define f_swap 1u
+#define f_ext 2u
+
+  /* --- Sort out some initial flags --- */
+
+  if (xx || yy)
+    f |= f_ext;
+
+  /* --- Ensure that @a@ is larger than @b@ --- *
+   *
+   * If they're the same length we don't care which order they're in, so this
+   * unsigned comparison is fine.
+   */
+
+  if (MPX_UCMP(a->v, a->vl, <, b->v, b->vl)) {
+    t = a; a = b; b = t;
+    f |= f_swap;
+  }
+
+  /* --- Check for zeroness --- */
+
+  if (MP_EQ(b, MP_ZERO)) {
+
+    /* --- Store %$|a|$% as the GCD --- */
+
+    if (gcd) {
+      if (*gcd) MP_DROP(*gcd);
+      a = MP_COPY(a);
+      *gcd = a;
+    }
+
+    /* --- Store %$1$% and %$0$% in the appropriate bins --- */
+
+    if (f & f_ext) {
+      if (f & f_swap) {
+	mp **t = xx; xx = yy; yy = t;
+      }
+      if (xx) {
+	if (*xx) MP_DROP(*xx);
+	if (MP_EQ(a, MP_ZERO))
+	  *xx = MP_ZERO;
+	else
+	  *xx = MP_ONE;
+      }
+      if (yy) {
+	if (*yy) MP_DROP(*yy);
+	*yy = MP_ZERO;
+      }
+    }
+    return;
+  }
+
+  /* --- Main extended Euclidean algorithm --- */
+
+  u = MP_COPY(a);
+  v = MP_COPY(b);
+
+  while (!MP_ZEROP(v)) {
+    gf_div(&q, &u, u, v);
+    if (f & f_ext) {
+      t = gf_mul(spare, X, q);
+      t = gf_add(t, t, x);
+      spare = x; x = X; X = t;
+      t = gf_mul(spare, Y, q);
+      t = gf_add(t, t, y);
+      spare = y; y = Y; Y = t;
+    }
+    t = u; u = v; v = t;
+  }
+
+  MP_DROP(q); if (spare) MP_DROP(spare);
+  if (!gcd)
+    MP_DROP(u);
+  else {
+    if (*gcd) MP_DROP(*gcd);
+    u->f &= ~MP_NEG;
+    *gcd = u;
+  }
+
+  /* --- Perform a little normalization --- */
+
+  if (f & f_ext) {
+
+    /* --- If @a@ and @b@ got swapped, swap the coefficients back --- */
+
+    if (f & f_swap) {
+      t = x; x = y; y = t;
+      t = a; a = b; b = t;
+    }
+
+    /* --- Store the results --- */
+
+    if (!xx)
+      MP_DROP(x);
+    else {
+      if (*xx) MP_DROP(*xx);
+      *xx = x;
+    }
+
+    if (!yy)
+      MP_DROP(y);
+    else {
+      if (*yy) MP_DROP(*yy);
+      *yy = y;
+    }
+  }
+
+  MP_DROP(v);
+  MP_DROP(X); MP_DROP(Y);
+}
+
+/* -- @gf_modinv@ --- *
+ *
+ * Arguments:	@mp *d@ = destination
+ *		@mp *x@ = argument
+ *		@mp *p@ = modulus
+ *
+ * Returns:	The inverse %$x^{-1} \bmod p$%.
+ *
+ * Use:		Computes a modular inverse, the catch being that the
+ *		arguments and results are binary polynomials.  An assertion
+ *		fails if %$p$% has no inverse.
+ */
+
+mp *gf_modinv(mp *d, mp *x, mp *p)
+{
+  mp *g = MP_NEW;
+  gf_gcd(&g, 0, &d, p, x);
+  assert(MP_EQ(g, MP_ONE));
+  mp_drop(g);
+  return (d);
+}
+
+/*----- Test rig ----------------------------------------------------------*/
+
+#ifdef TEST_RIG
+
+static int gcd(dstr *v)
+{
+  int ok = 1;
+  mp *a = *(mp **)v[0].buf;
+  mp *b = *(mp **)v[1].buf;
+  mp *g = *(mp **)v[2].buf;
+  mp *x = *(mp **)v[3].buf;
+  mp *y = *(mp **)v[4].buf;
+
+  mp *gg = MP_NEW, *xx = MP_NEW, *yy = MP_NEW;
+  gf_gcd(&gg, &xx, &yy, a, b);
+  if (!MP_EQ(x, xx)) {
+    fputs("\n*** gf_gcd(x) failed", stderr);
+    fputs("\na	    = ", stderr); mp_writefile(a, stderr, 16);
+    fputs("\nb	    = ", stderr); mp_writefile(b, stderr, 16);
+    fputs("\nexpect = ", stderr); mp_writefile(x, stderr, 16);
+    fputs("\nresult = ", stderr); mp_writefile(xx, stderr, 16);
+    fputc('\n', stderr);
+    ok = 0;
+  }
+  if (!MP_EQ(y, yy)) {
+    fputs("\n*** gf_gcd(y) failed", stderr);
+    fputs("\na	    = ", stderr); mp_writefile(a, stderr, 16);
+    fputs("\nb	    = ", stderr); mp_writefile(b, stderr, 16);
+    fputs("\nexpect = ", stderr); mp_writefile(y, stderr, 16);
+    fputs("\nresult = ", stderr); mp_writefile(yy, stderr, 16);
+    fputc('\n', stderr);
+    ok = 0;
+  }
+
+  if (!ok) {
+    mp *ax = gf_mul(MP_NEW, a, xx);
+    mp *by = gf_mul(MP_NEW, b, yy);
+    ax = gf_add(ax, ax, by);
+    if (MP_EQ(ax, gg))
+      fputs("\n*** (Alternative result found.)\n", stderr);
+    MP_DROP(ax);
+    MP_DROP(by);
+  }
+
+  if (!MP_EQ(g, gg)) {
+    fputs("\n*** gf_gcd(gcd) failed", stderr);
+    fputs("\na	    = ", stderr); mp_writefile(a, stderr, 16);
+    fputs("\nb	    = ", stderr); mp_writefile(b, stderr, 16);
+    fputs("\nexpect = ", stderr); mp_writefile(g, stderr, 16);
+    fputs("\nresult = ", stderr); mp_writefile(gg, stderr, 16);
+    fputc('\n', stderr);
+    ok = 0;
+  }
+  MP_DROP(a); MP_DROP(b); MP_DROP(g); MP_DROP(x); MP_DROP(y);
+  MP_DROP(gg); MP_DROP(xx); MP_DROP(yy);
+  assert(mparena_count(MPARENA_GLOBAL) == 0);
+  return (ok);
+}
+
+static test_chunk tests[] = {
+  { "gcd", gcd, { &type_mp, &type_mp, &type_mp, &type_mp, &type_mp, 0 } },
+  { 0, 0, { 0 } }
+};
+
+int main(int argc, char *argv[])
+{
+  sub_init();
+  test_run(argc, argv, tests, SRCDIR "/t/gf");
+  return (0);
+}
+
+#endif
+
+/*----- That's all, folks -------------------------------------------------*/