Changeset ef72ff3 in git

Timestamp:

Aug 19, 1999, 10:31:10 AM (25 years ago)

Author:

Wilfred Pohl <pohl@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

c601e113508e77c9e23dc3dbdef91c223b128d36

Parents:

6af907a7a7d71fd3623a80d151ad4a95348ff2b5

Message:

Pohl: minor


git-svn-id: file:///usr/local/Singular/svn/trunk@3490 2c84dea3-7e68-4137-9b89-c4e89433aadc

Location:

Singular

Files:

• ideals.cc (modified) (5 diffs)
• matpol.cc (modified) (7 diffs)
• matpol.h (modified) (3 diffs)

Singular/ideals.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: ideals.cc,v 1.51 1999-08-17 17:02:30 Singular Exp $ */
+/* $Id: ideals.cc,v 1.52 1999-08-19 08:31:09 pohl Exp $ */
 /*
 * ABSTRACT - all basic methods to manipulate ideals
@@ -25 +25 @@
 
 
-#define WITH_OLD_MINOR
+/* #define WITH_OLD_MINOR */
 
 static poly * idpower;
@@ -2350 +2350 @@
 //  }
 //}
-/*3
-* produces recursively the ideal of all arxar-minors of a
-*/
-static void idRecMin(matrix a,int ar,poly *barDiv,ideal result,
-              int * nextPlace, int rowToChose=0)
-{
-//Print("Level: %d\n",ar);
-/*--- there is no non-zero minor coming from a------------*/
-  if((ar<0) || (ar>min(a->ncols,a->nrows)-1))
-  {
-    idDelete((ideal *)&a);
-    pDelete(barDiv);
-    return;
-  }
-
-/*--- initializing temporary structures-------------------*/
-  int i,j,r=rowToChose,c,newi,newp,k;
-  poly p=NULL;
-
-  if (ar==0)
-  {
-/*--- ar is 0, the matrix-entres are minors---------------*/
-    for (i=a->nrows;i>0;i--)
-    {
-      for (j=a->ncols;j>0;j--)
-      {
-        p = MATELEM(a,i,j);
-        if (p!=NULL)
-        {
-          //idEnterSet(p,result,nextPlace);
-          if (*nextPlace>=IDELEMS(result))
-          {
-            pEnlargeSet(&(result->m),IDELEMS(result),IDELEMS(result));
-            IDELEMS(result) *=2;
-          }
-          result->m[*nextPlace] = p;
-          (*nextPlace)++;
-          MATELEM(a,i,j) = NULL;
-        }
-      }
-    }
-    idTest(result);
-    idDelete((ideal*)&a);
-    pDelete(barDiv);
-    return;
-  }
-/*--- ar>0, we perform one step of the Bareiss algorithm--*/
-  p = pCopy(*barDiv);   //we had to store barDiv for the remaining loops
-  matrix nextStep = mpOneStepBareiss(a,barDiv,&r,&c);
-//Print("next row is: %d, next col: %d\n",r,c);
-/*--- there is no pivot - the det of matrix is zero -------------*/
-  if ((r*c==0) || (MATELEM(nextStep,nextStep->nrows,nextStep->ncols)==NULL))
-  {
-    idDelete((ideal*)&nextStep);
-    idDelete((ideal*)&a);
-    pDelete(&p);
-    // pDelete(barDiv); barDiv==NULL in this case
-    return;
-  }
-/*--- we read out the r-1 x c-1 matrix for the next step--*/
-  if ((a->nrows-1)*(a->ncols-1)>0)
-  {
-    matrix next = mpNew(a->nrows-1,a->ncols-1);
-    for (i=a->nrows-1;i>0;i--)
-    {
-      for (j=a->ncols-1;j>0;j--)
-      {
-        MATELEM(next,i,j) = MATELEM(nextStep,i,j);
-        MATELEM(nextStep,i,j) =NULL;
-      }
-    }
-    idDelete((ideal*)&nextStep);
-/*--- we call the next Step------------------------------*/
-    idRecMin(next,ar-1,barDiv,result,nextPlace);
-    next = NULL;
-  }
-  if ((*barDiv)!=NULL) pDelete(barDiv);
-/*--- now we have to take out the r-th row...------------*/
-  if (((a->nrows)>1) && (rowToChose==0))
-  {
-    if (nextStep!=NULL) idDelete((ideal*)&nextStep);
-    nextStep = mpNew(a->nrows-1,a->ncols);
-    for (i=r-1;i>0;i--)
-    {
-      for (j=a->ncols;j>0;j--)
-      {
-        MATELEM(nextStep,i,j) = pCopy(MATELEM(a,i,j));
-      }
-    }
-    for (i=a->nrows;i>r;i--)
-    {
-      for (j=a->ncols;j>0;j--)
-      {
-        MATELEM(nextStep,i-1,j) = pCopy(MATELEM(a,i,j));
-      }
-    }
-/*--- and to perform the algorithm with the rest---------*/
-    poly q=pCopy(p);
-    idRecMin(nextStep,ar,&q,result,nextPlace);
-    assume(q==NULL);
-    nextStep = NULL;
-  }
-/*--- now we have to take out the c-th col...------------*/
-  if ((a->nrows)>1)
-  {
-    if (nextStep!=NULL) idDelete((ideal*)&nextStep);
-    nextStep = mpNew(a->nrows,a->ncols-1);
-    for (i=a->nrows;i>0;i--)
-    {
-      for (j=c-1;j>0;j--)
-      {
-        MATELEM(nextStep,i,j) = MATELEM(a,i,j);
-        MATELEM(a,i,j) = NULL;
-      }
-    }
-    for (i=a->nrows;i>0;i--)
-    {
-      for (j=a->ncols;j>c;j--)
-      {
-        MATELEM(nextStep,i,j-1) = MATELEM(a,i,j);
-        MATELEM(a,i,j) = NULL;
-      }
-    }
-/*--- and to perform the algorithm with the rest---------*/
-    idDelete((ideal*)&a);
-    idRecMin(nextStep,ar,&p,result,nextPlace,r);
-    //assume(p==NULL);
-    nextStep = NULL;
-  }
-/*--- deleting temporary structures and returns----------*/
-  pDelete(&p);
-  return;
-}
 
 #ifdef WITH_OLD_MINOR
@@ -2555 +2422 @@
 /*2
 * compute all ar-minors of the matrix a
-* the caller of idRecMin
+* the caller of mpRecMin
 */
 ideal idMinors(matrix a, int ar)
 {
+  ideal result;
+  int elems=0;
+
   if((ar<=0) || (ar>min(a->ncols,a->nrows)))
   {
@@ -2564 +2434 @@
     return NULL;
   }
-  int i=0;
-  poly barDiv=NULL;
-  ideal result=idInit(16,1);
-  if (a->ncols>=a->nrows)
-  {
-    idRecMin(mpCopy(a),ar-1,&barDiv,result,&i);
-  }
-  else
-  {
-    idRecMin(mpTransp(a),ar-1,&barDiv,result,&i);
-  }
+  a = mpCopy(a);
+  result=idInit(31,1);
+  if(ar>1) mpRecMin(ar-1,result,elems,a,a->nrows,a->ncols,NULL);
+  else mpMinorToResult(result,elems,a,a->nrows,a->ncols);
+  idDelete((ideal *)&a);
   idSkipZeroes(result);
+  idTest(result);
   return result;
 }
 #endif
-
 
 /*2

Singular/matpol.cc

@@ -2 +2 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: matpol.cc,v 1.24 1999-06-29 13:03:31 pohl Exp $ */
+/* $Id: matpol.cc,v 1.25 1999-08-19 08:31:10 pohl Exp $ */
 
 /*
@@ -29 +29 @@
 /*0 implementation*/
 
+static void ppp(matrix);
+static void qqq() {int i=0;}
+
 typedef int perm[100];
-static poly mpDivide(poly a, poly b);
 static void mpReplace(int j, int n, int &sign, int *perm);
-static float mpPolyWeight(poly p);
 static int mpNextperm(perm * z, int max);
 static poly mpLeibnitz(matrix a);
 static poly minuscopy (poly p);
 static poly pInsert(poly p1, poly p2);
+static poly mpExdiv ( poly m, poly d);
 static poly mpSelect (poly fro, poly what);
-static poly mpExdiv ( poly m, poly d);
+
+static void mpPartClean(matrix, int, int);
+static void mpFinalClean(matrix);
+static int mpPrepareRow (matrix, int, int);
+static int mpPreparePiv (matrix, int, int);
+static int mpPivBar(matrix, int, int);
+static int mpPivRow(matrix, int, int);
+static float mpPolyWeight(poly);
+static void mpSwapRow(matrix, int, int, int);
+static void mpSwapCol(matrix, int, int, int);
+static void mpElimBar(matrix, matrix, poly, int, int);
 
 /*2
@@ -336 +348 @@
 
 /*2
-*  caller of 'Bareiss' algorithm,
-*  return an list of a matrix and an intvec:
-*    the matrix is lower triangular and the result,
-*    the intvec is the performed permutation of columns.
-*/
-lists mpBareiss (matrix a, BOOLEAN sw)
-{
-  poly div;
-  matrix c = mpCopy(a);
-  mp_permmatrix *Bareiss = new mp_permmatrix(c);
-  row_col_weight w(Bareiss->mpGetRdim(), Bareiss->mpGetCdim());
-  intvec *v = new intvec(Bareiss->mpGetCdim());
-  lists res=(lists)Alloc(sizeof(slists));
-
-  if (sw) WarnS(feNotImplemented);
-  /* Bareiss */
-  div = NULL;
-  while(Bareiss->mpPivotBareiss(&w))
-  {
-    Bareiss->mpElimBareiss(div);
-    div = Bareiss->mpGetElem(Bareiss->mpGetRdim(), Bareiss->mpGetCdim());
-  }
-  Bareiss->mpToIntvec(v);
-  Bareiss->mpRowReorder();
-  Bareiss->mpColReorder();
-  Bareiss->mpSaveArray();
-  delete Bareiss;
-
-  res->Init(2);
-  res->m[0].rtyp=MATRIX_CMD;
-  res->m[0].data=(void *)c;
-  res->m[1].rtyp=INTVEC_CMD;
-  res->m[1].data=(void *)v;
-  return res;
-}
-
-/*2
-*  one step of 'Bareiss' algorithm
-*  for application in minor
-*  assume to have a full matrix
-*  if *H!=0, then divide by *H (the pivot from the step before)
-*  returns the choosen pivot *H=m[*r,*c]
-*  the result has the pivot at the right lower corner
-*/
-matrix mpOneStepBareiss (matrix a, poly *H, int *r, int *c)
-{
-  poly div=*H;
-  matrix re = mpCopy(a);
-  mp_permmatrix *Bareiss = new mp_permmatrix(re);
-  row_col_weight w(Bareiss->mpGetRdim(), Bareiss->mpGetCdim());
-  int row = *r;
-
-  /* step of Bareiss */
-  if(((row!=0) && Bareiss->mpPivotRow(&w,row-1)) || Bareiss->mpPivotBareiss(&w))
-  {
-    Bareiss->mpElimBareiss(div);
-    div = Bareiss->mpGetElem(Bareiss->mpGetRdim(), Bareiss->mpGetCdim());
-    pDelete(H);
-    *H = pCopy(div);
-    *c = Bareiss->mpGetCol()+1;
-    *r = Bareiss->mpGetRow()+1;
-    Bareiss->mpRowReorder();
-    Bareiss->mpColReorder();
+* entries of a are minors and go to result
+*/
+void mpMinorToResult(ideal result, int &elems, matrix a, int r, int c)
+{
+  poly *q1;
+  int e=IDELEMS(result);
+  int i,j;
+
+  if(e<0X80000000)
+  {    
+    for (i=r-1;i>=0;i--)
+    {
+      q1 = &(a->m)[i*a->ncols];
+      for (j=c-1;j>=0;j--)
+      {
+        if (q1[j]!=NULL)
+        {
+          if (elems>=e)
+          {
+            pEnlargeSet(&(result->m),e,e+1);
+            e += e+1;
+            IDELEMS(result) =e;
+          }
+          result->m[elems] = q1[j];
+          q1[j] = NULL;
+          elems++;
+        }
+      }
+    }
   }
   else
   {
-    pDelete(H);
-    *H = NULL;
-    *c = *r = 0;
-  }
-  Bareiss->mpSaveArray();
-  idTest((ideal)re);
-  delete Bareiss;
-  return re;
+    for (i=r-1;i>=0;i--)
+    {
+      q1 = &(a->m)[i*a->ncols];
+      for (j=c-1;j>=0;j--)
+      {
+        if (q1[j]!=NULL)
+        {
+          if (elems>=e)
+          {
+            Werror("stop after %d minors",elems);
+            HALT();
+          }
+          result->m[elems] = q1[j];
+          q1[j] = NULL;
+          elems++;
+        }
+      }
+    }
+  }
+}
+
+/*2
+* produces recursively the ideal of all arxar-minors of a
+*/
+void mpRecMin(int ar,ideal result,int &elems,matrix a,int lr,int lc,poly barDiv)
+{
+  int k;
+  int kr=lr-1,kc=lc-1;
+  matrix nextLevel=mpNew(kr,kc);
+
+  loop
+  {
+/*--- look for an optimal row and bring it to last position ------------*/
+    if(mpPrepareRow(a,lr,lc)==0) break;
+/*--- now take all pivotŽs from the last row ------------*/
+    k = lc;
+    loop
+    {
+      if(mpPreparePiv(a,lr,k)==0) break;
+      mpElimBar(a,nextLevel,barDiv,lr,k);
+      k--;
+      if (ar>1)
+      {
+        mpRecMin(ar-1,result,elems,nextLevel,kr,k,a->m[kr*a->ncols+k]);
+        mpPartClean(nextLevel,kr,k);
+      }
+      else mpMinorToResult(result,elems,nextLevel,kr,k);
+      if (ar>k-1) break;
+    }
+    if (ar>=kr) break;
+/*--- now we have to take out the last row...------------*/
+    lr = kr;
+    kr--;
+  }
+  mpFinalClean(nextLevel);
 }
 
@@ -852 +877 @@
 }
 
+/*2
+*exact divisor: let d  == x^i*y^j, m is thought to have only one term;
+*    return m/d iff d divides m, and no x^k*y^l (k>i or l>j) divides m
+*/
+static poly mpExdiv ( poly m, poly d)
+{
+  int i;
+  poly h = pHead(m);
+  for (i=1; i<=pVariables; i++)
+  {
+    if (pGetExp(d,i) > 0)
+    {
+      if (pGetExp(d,i) != pGetExp(h,i))
+      {
+        pDelete(&h);
+        return NULL;
+      }
+      pSetExp(h,i,0);
+    }
+  }
+  pSetm(h);
+  return h;
+}
+
 void mpCoef2(poly v, poly mon, matrix *c, matrix *m)
 {
@@ -1402 +1451 @@
 }
 
-/*2
-* exact division a/b, used in Bareiss algorithm
-* a destroyed, b NOT destroyed
-*/
-static poly mpDivide(poly a, poly b)
-{
-  number x, y, z;
-  poly r, tail, t, h, h0;
-  int i, deg;
-
-  r = a;
-  x = pGetCoeff(b);
-  deg = pTotaldegree(b);
-  tail = pNext(b);
-  if (tail == NULL)
-  {
-    do
-    {
-      if (deg != 0)
-      {
-        for (i=pVariables; i; i--)
-          pSubExp(r,i,  pGetExp(b,i));
-        pSetm(r);
-      }
-      y = nDiv(pGetCoeff(r),x);
-      nNormalize(y);
-      pSetCoeff(r,y);
-      pIter(r);
-    } while (r != NULL);
-    //pTest(a);
-    return a;
-  }
-  h0 = pInit();
-  do
-  {
-    if (deg != 0)
-    {
-      for (i=pVariables; i>0; i--)
-        pSubExp(r,i,pGetExp(b,i));
-      pSetm(r);
-    }
-    y = nDiv(pGetCoeff(r), x);
-    nNormalize(y);
-    pSetCoeff(r,y);
-    t = tail;
-    h = h0;
-    do
-    {
-      h = pNext(h) = pInit();
-      for (i=pVariables; i>0; i--)
-        pSetExp(h,i, pGetExp(r,i)+pGetExp(t,i));
-      pSetm(h);
-      z = nMult(y, pGetCoeff(t));
-      pSetCoeff0(h,nNeg(z));
-      pIter(t);
-    } while (t != NULL);
-    pNext(h) = NULL;
-    r = pNext(r) = pAdd(pNext(r),pNext(h0));
-  } while (r!=NULL);
-  pFree1(h0);
-  //pTest(a);
-  return a;
-}
-
 /*
 * perform replacement for pivot strategy in Bareiss algorithm
@@ -1481 +1466 @@
     sign = -sign;
   }
-}
-
-/*
-* weigth of a polynomial, for pivot strategy
-* modify this for characteristic 0 !!!
-*/
-static float mpPolyWeight(poly p)
-{
-  int i;
-  float res;
-
-  if (pNext(p) == NULL)
-  {
-    res = (float)nSize(pGetCoeff(p));
-    if (pTotaldegree(p) != 0) res += 1.0;
-  }
-  else
-  {
-    i = 0;
-    res = 0.0;
-    do
-    {
-      i++;
-      res += (float)nSize(pGetCoeff(p));
-      pIter(p);
-    }
-    while (p);
-    res += (float)i;
-  }
-  return res;
 }
 
@@ -1689 +1644 @@
 }
 
-/*2
-*exact divisor: let d  == x^i*y^j, m is thought to have only one term;
-*    return m/d iff d divides m, and no x^k*y^l (k>i or l>j) divides m
-*/
-static poly mpExdiv ( poly m, poly d)
+/* 
+*static void ppp(matrix a)
+*{
+*  int j,i,r=a->nrows,c=a->ncols;
+*  for(j=1;j<=r;j++)
+*  {
+*    for(i=1;i<=c;i++)
+*    {
+*      if(MATELEM(a,j,i)!=NULL) Print("X");
+*      else Print("0");
+*    }
+*    Print("\n");
+*  }
+*}
+*/
+
+static void mpPartClean(matrix a, int lr, int lc)
+{
+  poly *q1;
+  int i,j;
+
+  for (i=lr-1;i>=0;i--)
+  {
+    q1 = &(a->m)[i*a->ncols];
+    for (j=lc-1;j>=0;j--) if(q1[j]) pDelete(&q1[j]);
+  }
+}
+
+static void mpFinalClean(matrix a)
+{
+  Free((ADDRESS)a->m,a->nrows*a->ncols*sizeof(poly));
+  Free((ADDRESS)a,sizeof(*a));
+}
+
+/*2
+*  prepare one step of 'Bareiss' algorithm
+*  for application in minor
+*/
+static int mpPrepareRow (matrix a, int lr, int lc)
+{
+  int r;
+
+  r = mpPivBar(a,lr,lc);
+  if(r==0) return 0;
+  if(r<lr) mpSwapRow(a, r, lr, lc);
+  return 1;
+}
+
+/*2
+*  prepare one step of 'Bareiss' algorithm
+*  for application in minor
+*/
+static int mpPreparePiv (matrix a, int lr, int lc)
+{
+  int c;
+
+  c = mpPivRow(a, lr, lc);
+  if(c==0) return 0;
+  if(c<lc) mpSwapCol(a, c, lr, lc);
+  return 1;
+}
+
+/*
+* find best row
+*/
+static int mpPivBar(matrix a, int lr, int lc)
+{
+  float f1, f2;
+  poly *q1;
+  int i,j,io;
+
+  io = -1;
+  f1 = 1.0e30;
+  for (i=lr-1;i>=0;i--)
+  {
+    q1 = &(a->m)[i*a->ncols];
+    f2 = 0.0;
+    for (j=lc-1;j>=0;j--)
+    {
+      if (q1[j]!=NULL)
+        f2 += mpPolyWeight(q1[j]);
+    }
+    if ((f2!=0.0) && (f2<f1))
+    {
+      f1 = f2;
+      io = i;
+    }
+  }
+  if (io<0) return 0;
+  else return io+1; 
+}
+
+/*
+* find pivot in the last row
+*/
+static int mpPivRow(matrix a, int lr, int lc)
+{
+  float f1, f2;
+  poly *q1;
+  int j,jo;
+
+  jo = -1;
+  f1 = 1.0e30;
+  q1 = &(a->m)[(lr-1)*a->ncols];
+  for (j=lc-1;j>=0;j--)
+  {
+    if (q1[j]!=NULL)
+    {
+      f2 = mpPolyWeight(q1[j]);
+      if (f2<f1)
+      {
+        f1 = f2;
+        jo = j;
+      }
+    }
+  }
+  if (jo<0) return 0;
+  else return jo+1;
+}
+
+/*
+* weigth of a polynomial, for pivot strategy
+*/
+static float mpPolyWeight(poly p)
 {
   int i;
-  poly h = pHead(m);
-  for (i=1; i<=pVariables; i++)
-  {
-    if (pGetExp(d,i) > 0)
-    {
-      if (pGetExp(d,i) != pGetExp(h,i))
-      {
-        pDelete(&h);
-        return NULL;
-      }
-      pSetExp(h,i,0);
-    }
-  }
-  pSetm(h);
-  return h;
-}
-
+  float res;
+
+  if (pNext(p) == NULL)
+  {
+    res = (float)nSize(pGetCoeff(p));
+    for (i=pVariables;i>0;i--)
+    {
+      if(pGetExp(p,i)!=0)
+      {
+        res += 2.0;
+        break;
+      }
+    }
+  }
+  else
+  {
+    res = 0.0;
+    do
+    {
+      res += (float)nSize(pGetCoeff(p))+2.0;
+      pIter(p);
+    }
+    while (p);
+  }
+  return res;
+}
+
+static void mpSwapRow(matrix a, int pos, int lr, int lc)
+{
+  poly sw;
+  int j;
+  polyset a2 = a->m, a1 = &a2[a->ncols*(pos-1)];
+
+  a2 = &a2[a->ncols*(lr-1)];
+  for (j=lc-1; j>=0; j--)
+  {
+    sw = a1[j];
+    a1[j] = a2[j];
+    a2[j] = sw;
+  }
+}
+
+static void mpSwapCol(matrix a, int pos, int lr, int lc)
+{
+  poly sw;
+  int j;
+  polyset a2 = a->m, a1 = &a2[pos-1];
+
+  a2 = &a2[lc-1];
+  for (j=a->ncols*(lr-1); j>=0; j-=a->ncols)
+  {
+    sw = a1[j];
+    a1[j] = a2[j];
+    a2[j] = sw;
+  }
+}
+
+static void mpElimBar(matrix a0, matrix re, poly div, int lr, int lc)
+{
+  int r=lr-1, c=lc-1;
+  poly *b = a0->m, *x = re->m; 
+  poly piv, elim, q1, q2, *ap, *a, *q;
+  int i, j;
+
+  ap = &b[r*a0->ncols];
+  piv = ap[c];
+  for(j=c-1; j>=0; j--) 
+    if (ap[j] != NULL) ap[j] = pNeg(ap[j]);
+  for(i=r-1; i>=0; i--)
+  {
+    a = &b[i*a0->ncols];
+    q = &x[i*re->ncols];
+    if (a[c] != NULL)
+    {
+      elim = a[c];
+      for (j=c-1; j>=0; j--)
+      {
+        q1 = NULL;
+        if (a[j] != NULL)
+        {
+          q1 = smMultDiv(a[j], piv, div);
+          if (ap[j] != NULL)
+          {
+            q2 = smMultDiv(ap[j], elim, div);
+            q1 = pAdd(q1,q2);
+          }
+        }
+        else if (ap[j] != NULL)
+          q1 = smMultDiv(ap[j], elim, div);
+        if (q1 != NULL)
+        {
+          if (div)
+            smSpecialPolyDiv(q1, div);
+          q[j] = q1;
+        }
+      }
+    }
+    else
+    {
+      for (j=c-1; j>=0; j--)
+      {
+        if (a[j] != NULL)
+        {
+          q1 = smMultDiv(a[j], piv, div);
+          if (div)
+            smSpecialPolyDiv(q1, div);
+          q[j] = q1;
+        }
+      }
+    }
+  }
+}

Singular/matpol.h

@@ -4 +4 @@
 *  Computer Algebra System SINGULAR     *
 ****************************************/
-/* $Id: matpol.h,v 1.7 1998-07-16 06:44:29 obachman Exp $ */
+/* $Id: matpol.h,v 1.8 1999-08-19 08:31:10 pohl Exp $ */
 /*
 * ABSTRACT
@@ -46 +46 @@
 poly TraceOfProd ( matrix a, matrix b, int n);
 
-lists mpBareiss (matrix a, BOOLEAN diagonal);
-matrix mpOneStepBareiss (matrix a, poly *H, int *r, int *c);
 poly mpDet (matrix m);
 matrix mpWedge(matrix a, int ar);
@@ -70 +68 @@
 Thus f = sum co[1,i]*co[2,i], i = 1..cols, rows equals 2. */
 void mpCoef2(poly v, poly vars, matrix *c, matrix *m);
+/* for minors with Bareiss */
+void mpRecMin(int, ideal, int &, matrix, int, int, poly);
+void mpMinorToResult(ideal, int &, matrix, int, int);
 
 #endif