Public Member Functions | Private Member Functions | Private Attributes
sparse_mat Class Reference

Public Member Functions

 sparse_mat (ideal, const ring)
 
 ~sparse_mat ()
 
int smGetSign ()
 
smpolysmGetAct ()
 
int smGetRed ()
 
ideal smRes2Mod ()
 
poly smDet ()
 
void smNewBareiss (int, int)
 
void smToIntvec (intvec *)
 

Private Member Functions

void smColToRow ()
 
void smRowToCol ()
 
void smFinalMult ()
 
void smSparseHomog ()
 
void smWeights ()
 
void smPivot ()
 
void smNewWeights ()
 
void smNewPivot ()
 
void smZeroElim ()
 
void smToredElim ()
 
void smCopToRes ()
 
void smSelectPR ()
 
void sm1Elim ()
 
void smHElim ()
 
void smMultCol ()
 
poly smMultPoly (smpoly)
 
void smActDel ()
 
void smColDel ()
 
void smPivDel ()
 
void smSign ()
 
void smInitPerm ()
 
int smCheckNormalize ()
 
void smNormalize ()
 

Private Attributes

int nrows
 
int ncols
 
int sign
 
int act
 
int crd
 
int tored
 
int inred
 
int rpiv
 
int cpiv
 
int normalize
 
int * perm
 
float wpoints
 
float * wrw
 
float * wcl
 
smpolym_act
 
smpolym_res
 
smpolym_row
 
smpoly red
 
smpoly piv
 
smpoly oldpiv
 
smpoly dumm
 
ring _R
 

Detailed Description

Definition at line 129 of file sparsmat.cc.

Constructor & Destructor Documentation

§ sparse_mat()

sparse_mat::sparse_mat ( ideal  smat,
const ring  RR 
)

Definition at line 442 of file sparsmat.cc.

443 {
444  int i;
445  poly* pmat;
446  _R=RR;
447 
448  ncols = smat->ncols;
449  nrows = id_RankFreeModule(smat,RR);
450  if (nrows <= 0)
451  {
452  m_act = NULL;
453  return;
454  }
455  sign = 1;
456  inred = act = ncols;
457  crd = 0;
458  tored = nrows; // without border
459  i = tored+1;
460  perm = (int *)omAlloc(sizeof(int)*(i+1));
461  perm[i] = 0;
462  m_row = (smpoly *)omAlloc0(sizeof(smpoly)*i);
463  wrw = (float *)omAlloc(sizeof(float)*i);
464  i = ncols+1;
465  wcl = (float *)omAlloc(sizeof(float)*i);
466  m_act = (smpoly *)omAlloc(sizeof(smpoly)*i);
467  m_res = (smpoly *)omAlloc0(sizeof(smpoly)*i);
470  m_res[0]->m = NULL;
471  pmat = smat->m;
472  for(i=ncols; i; i--)
473  {
474  m_act[i] = sm_Poly2Smpoly(pmat[i-1], RR);
475  pmat[i-1] = NULL;
476  }
477  this->smZeroElim();
478  oldpiv = NULL;
479 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
smpoly * m_res
Definition: sparsmat.cc:143
smpoly dumm
Definition: sparsmat.cc:147
omBin smprec_bin
Definition: sparsmat.cc:79
sm_prec * smpoly
Definition: sparsmat.cc:51
#define omAlloc(size)
Definition: omAllocDecl.h:210
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
static smpoly sm_Poly2Smpoly(poly, const ring)
Definition: sparsmat.cc:2152
float * wrw
Definition: sparsmat.cc:141
int i
Definition: cfEzgcd.cc:123
int * perm
Definition: sparsmat.cc:139
smpoly * m_act
Definition: sparsmat.cc:142
smpoly * m_row
Definition: sparsmat.cc:144
float * wcl
Definition: sparsmat.cc:141
#define NULL
Definition: omList.c:10
void smZeroElim()
Definition: sparsmat.cc:1190
polyrec * poly
Definition: hilb.h:10
smpoly oldpiv
Definition: sparsmat.cc:146
#define omAlloc0(size)
Definition: omAllocDecl.h:211

§ ~sparse_mat()

sparse_mat::~sparse_mat ( )

Definition at line 484 of file sparsmat.cc.

485 {
486  int i;
487  if (m_act == NULL) return;
490  i = ncols+1;
491  omFreeSize((ADDRESS)m_res, sizeof(smpoly)*i);
492  omFreeSize((ADDRESS)m_act, sizeof(smpoly)*i);
493  omFreeSize((ADDRESS)wcl, sizeof(float)*i);
494  i = nrows+1;
495  omFreeSize((ADDRESS)wrw, sizeof(float)*i);
496  omFreeSize((ADDRESS)m_row, sizeof(smpoly)*i);
497  omFreeSize((ADDRESS)perm, sizeof(int)*(i+1));
498 }
smpoly * m_res
Definition: sparsmat.cc:143
smpoly dumm
Definition: sparsmat.cc:147
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
omBin smprec_bin
Definition: sparsmat.cc:79
void * ADDRESS
Definition: auxiliary.h:115
sm_prec * smpoly
Definition: sparsmat.cc:51
float * wrw
Definition: sparsmat.cc:141
int i
Definition: cfEzgcd.cc:123
int * perm
Definition: sparsmat.cc:139
smpoly * m_act
Definition: sparsmat.cc:142
smpoly * m_row
Definition: sparsmat.cc:144
float * wcl
Definition: sparsmat.cc:141
#define NULL
Definition: omList.c:10
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259

Member Function Documentation

§ sm1Elim()

void sparse_mat::sm1Elim ( )
private

Definition at line 855 of file sparsmat.cc.

856 {
857  poly p = piv->m; // pivotelement
858  smpoly c = m_act[act]; // pivotcolumn
859  smpoly r = red; // row to reduce
860  smpoly res, a, b;
861  poly w, ha, hb;
862 
863  if ((c == NULL) || (r == NULL))
864  {
865  while (r!=NULL) sm_ElemDelete(&r,_R);
866  return;
867  }
868  do
869  {
870  a = m_act[r->pos];
871  res = dumm;
872  res->n = NULL;
873  b = c;
874  w = r->m;
875  loop // combine the chains a and b: p*a + w*b
876  {
877  if (a == NULL)
878  {
879  do
880  {
881  res = res->n = smElemCopy(b);
882  res->m = pp_Mult_qq(b->m, w,_R);
883  res->e = 1;
884  res->f = sm_PolyWeight(res,_R);
885  b = b->n;
886  } while (b != NULL);
887  break;
888  }
889  if (a->pos < b->pos)
890  {
891  res = res->n = a;
892  a = a->n;
893  }
894  else if (a->pos > b->pos)
895  {
896  res = res->n = smElemCopy(b);
897  res->m = pp_Mult_qq(b->m, w,_R);
898  res->e = 1;
899  res->f = sm_PolyWeight(res,_R);
900  b = b->n;
901  }
902  else
903  {
904  ha = pp_Mult_qq(a->m, p,_R);
905  p_Delete(&a->m,_R);
906  hb = pp_Mult_qq(b->m, w,_R);
907  ha = p_Add_q(ha, hb,_R);
908  if (ha != NULL)
909  {
910  a->m = ha;
911  a->e = 1;
912  a->f = sm_PolyWeight(a,_R);
913  res = res->n = a;
914  a = a->n;
915  }
916  else
917  {
918  sm_ElemDelete(&a,_R);
919  }
920  b = b->n;
921  }
922  if (b == NULL)
923  {
924  res->n = a;
925  break;
926  }
927  }
928  m_act[r->pos] = dumm->n;
929  sm_ElemDelete(&r,_R);
930  } while (r != NULL);
931 }
const poly a
Definition: syzextra.cc:212
smpoly dumm
Definition: sparsmat.cc:147
loop
Definition: myNF.cc:98
return P p
Definition: myNF.cc:203
sm_prec * smpoly
Definition: sparsmat.cc:51
smpoly red
Definition: sparsmat.cc:145
poly res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
static poly pp_Mult_qq(poly p, poly q, const ring r)
Definition: p_polys.h:1070
smpoly piv
Definition: sparsmat.cc:146
smpoly * m_act
Definition: sparsmat.cc:142
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:843
#define NULL
Definition: omList.c:10
const CanonicalForm & w
Definition: facAbsFact.cc:55
static smpoly smElemCopy(smpoly)
Definition: sparsmat.cc:2140
static float sm_PolyWeight(smpoly, const ring)
Definition: sparsmat.cc:2230
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:877
const poly b
Definition: syzextra.cc:213
static void sm_ElemDelete(smpoly *, const ring)
Definition: sparsmat.cc:2131

§ smActDel()

void sparse_mat::smActDel ( )
private

Definition at line 1531 of file sparsmat.cc.

1532 {
1533  smpoly a;
1534  int i;
1535 
1536  for (i=act; i; i--)
1537  {
1538  a = m_act[i];
1539  do
1540  {
1541  sm_ElemDelete(&a,_R);
1542  } while (a != NULL);
1543  }
1544 }
const poly a
Definition: syzextra.cc:212
sm_prec * smpoly
Definition: sparsmat.cc:51
int i
Definition: cfEzgcd.cc:123
smpoly * m_act
Definition: sparsmat.cc:142
#define NULL
Definition: omList.c:10
static void sm_ElemDelete(smpoly *, const ring)
Definition: sparsmat.cc:2131

§ smCheckNormalize()

int sparse_mat::smCheckNormalize ( )
private

Definition at line 1469 of file sparsmat.cc.

1470 {
1471  int i;
1472  smpoly a;
1473 
1474  for (i=act; i; i--)
1475  {
1476  a = m_act[i];
1477  do
1478  {
1479  if(sm_HaveDenom(a->m,_R)) return 1;
1480  a = a->n;
1481  } while (a != NULL);
1482  }
1483  return 0;
1484 }
const poly a
Definition: syzextra.cc:212
sm_prec * smpoly
Definition: sparsmat.cc:51
static BOOLEAN sm_HaveDenom(poly, const ring)
Definition: sparsmat.cc:2259
int i
Definition: cfEzgcd.cc:123
smpoly * m_act
Definition: sparsmat.cc:142
#define NULL
Definition: omList.c:10

§ smColDel()

void sparse_mat::smColDel ( )
private

Definition at line 1549 of file sparsmat.cc.

1550 {
1551  smpoly a = m_act[act];
1552 
1553  while (a != NULL)
1554  {
1555  sm_ElemDelete(&a,_R);
1556  }
1557 }
const poly a
Definition: syzextra.cc:212
sm_prec * smpoly
Definition: sparsmat.cc:51
smpoly * m_act
Definition: sparsmat.cc:142
#define NULL
Definition: omList.c:10
static void sm_ElemDelete(smpoly *, const ring)
Definition: sparsmat.cc:2131

§ smColToRow()

void sparse_mat::smColToRow ( )
private

Definition at line 1137 of file sparsmat.cc.

1138 {
1139  smpoly c = m_act[act];
1140  smpoly h;
1141 
1142  while (c != NULL)
1143  {
1144  h = c;
1145  c = c->n;
1146  h->n = m_row[h->pos];
1147  m_row[h->pos] = h;
1148  h->pos = crd;
1149  }
1150 }
sm_prec * smpoly
Definition: sparsmat.cc:51
smpoly * m_act
Definition: sparsmat.cc:142
smpoly * m_row
Definition: sparsmat.cc:144
#define NULL
Definition: omList.c:10
static Poly * h
Definition: janet.cc:978

§ smCopToRes()

void sparse_mat::smCopToRes ( )
private

Definition at line 1259 of file sparsmat.cc.

1260 {
1261  smpoly a,ap,r,h;
1262  int i,j,k,l;
1263 
1264  i = 0;
1265  if (act)
1266  {
1267  a = m_act[act]; // init perm
1268  do
1269  {
1270  i++;
1271  perm[crd+i] = a->pos;
1272  a = a->n;
1273  } while ((a != NULL) && (a->pos <= tored));
1274  for (j=act-1;j;j--) // load all positions of perm
1275  {
1276  a = m_act[j];
1277  k = 1;
1278  loop
1279  {
1280  if (perm[crd+k] >= a->pos)
1281  {
1282  if (perm[crd+k] > a->pos)
1283  {
1284  for (l=i;l>=k;l--) perm[crd+l+1] = perm[crd+l];
1285  perm[crd+k] = a->pos;
1286  i++;
1287  }
1288  a = a->n;
1289  if ((a == NULL) || (a->pos > tored)) break;
1290  }
1291  k++;
1292  if ((k > i) && (a->pos <= tored))
1293  {
1294  do
1295  {
1296  i++;
1297  perm[crd+i] = a->pos;
1298  a = a->n;
1299  } while ((a != NULL) && (a->pos <= tored));
1300  break;
1301  }
1302  }
1303  }
1304  }
1305  for (j=act;j;j--) // renumber m_act
1306  {
1307  k = 1;
1308  a = m_act[j];
1309  while ((a != NULL) && (a->pos <= tored))
1310  {
1311  if (perm[crd+k] == a->pos)
1312  {
1313  a->pos = crd+k;
1314  a = a->n;
1315  }
1316  k++;
1317  }
1318  }
1319  tored = crd+i;
1320  for(k=1;k<=i;k++) // clean this from m_row
1321  {
1322  j = perm[crd+k];
1323  if (m_row[j] != NULL)
1324  {
1325  r = m_row[j];
1326  m_row[j] = NULL;
1327  do
1328  {
1329  ap = m_res[r->pos];
1330  loop
1331  {
1332  a = ap->n;
1333  if (a == NULL)
1334  {
1335  h = ap->n = r;
1336  r = r->n;
1337  h->n = NULL;
1338  h->pos = crd+k;
1339  break;
1340  }
1341  ap = a;
1342  }
1343  } while (r!=NULL);
1344  }
1345  }
1346  while(act) // clean m_act
1347  {
1348  crd++;
1349  m_res[crd] = m_act[act];
1350  act--;
1351  }
1352  for (i=1;i<=tored;i++) // take the rest of m_row
1353  {
1354  if(m_row[i] != NULL)
1355  {
1356  tored++;
1357  r = m_row[i];
1358  m_row[i] = NULL;
1359  perm[tored] = i;
1360  do
1361  {
1362  ap = m_res[r->pos];
1363  loop
1364  {
1365  a = ap->n;
1366  if (a == NULL)
1367  {
1368  h = ap->n = r;
1369  r = r->n;
1370  h->n = NULL;
1371  h->pos = tored;
1372  break;
1373  }
1374  ap = a;
1375  }
1376  } while (r!=NULL);
1377  }
1378  }
1379  for (i=tored+1;i<=nrows;i++) // take the rest of m_row
1380  {
1381  if(m_row[i] != NULL)
1382  {
1383  r = m_row[i];
1384  m_row[i] = NULL;
1385  do
1386  {
1387  ap = m_res[r->pos];
1388  loop
1389  {
1390  a = ap->n;
1391  if (a == NULL)
1392  {
1393  h = ap->n = r;
1394  r = r->n;
1395  h->n = NULL;
1396  h->pos = i;
1397  break;
1398  }
1399  ap = a;
1400  }
1401  } while (r!=NULL);
1402  }
1403  }
1404  while (inred < ncols) // take unreducable
1405  {
1406  crd++;
1407  inred++;
1408  m_res[crd] = m_res[inred];
1409  }
1410 }
const poly a
Definition: syzextra.cc:212
smpoly * m_res
Definition: sparsmat.cc:143
loop
Definition: myNF.cc:98
sm_prec * smpoly
Definition: sparsmat.cc:51
int k
Definition: cfEzgcd.cc:93
const ring r
Definition: syzextra.cc:208
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
int * perm
Definition: sparsmat.cc:139
smpoly * m_act
Definition: sparsmat.cc:142
smpoly * m_row
Definition: sparsmat.cc:144
#define NULL
Definition: omList.c:10
static Poly * h
Definition: janet.cc:978
int l
Definition: cfEzgcd.cc:94

§ smDet()

poly sparse_mat::smDet ( )

Definition at line 531 of file sparsmat.cc.

532 {
533  poly res = NULL;
534 
535  if (sign == 0)
536  {
537  this->smActDel();
538  return NULL;
539  }
540  if (act < 2)
541  {
542  if (act != 0) res = m_act[1]->m;
543  omFreeBin((void *)m_act[1], smprec_bin);
544  return res;
545  }
546  normalize = 0;
547  this->smInitPerm();
548  this->smPivot();
549  this->smSign();
550  this->smSelectPR();
551  this->sm1Elim();
552  crd++;
553  m_res[crd] = piv;
554  this->smColDel();
555  act--;
556  this->smZeroElim();
557  if (sign == 0)
558  {
559  this->smActDel();
560  return NULL;
561  }
562  if (act < 2)
563  {
564  this->smFinalMult();
565  this->smPivDel();
566  if (act != 0) res = m_act[1]->m;
567  omFreeBin((void *)m_act[1], smprec_bin);
568  return res;
569  }
570  loop
571  {
572  this->smNewPivot();
573  this->smSign();
574  this->smSelectPR();
575  this->smMultCol();
576  this->smHElim();
577  crd++;
578  m_res[crd] = piv;
579  this->smColDel();
580  act--;
581  this->smZeroElim();
582  if (sign == 0)
583  {
584  this->smPivDel();
585  this->smActDel();
586  return NULL;
587  }
588  if (act < 2)
589  {
590  if (TEST_OPT_PROT) PrintS(".\n");
591  this->smFinalMult();
592  this->smPivDel();
593  if (act != 0) res = m_act[1]->m;
594  omFreeBin((void *)m_act[1], smprec_bin);
595  return res;
596  }
597  }
598 }
smpoly * m_res
Definition: sparsmat.cc:143
#define TEST_OPT_PROT
Definition: options.h:98
loop
Definition: myNF.cc:98
void smPivot()
Definition: sparsmat.cc:698
omBin smprec_bin
Definition: sparsmat.cc:79
void smActDel()
Definition: sparsmat.cc:1531
int normalize
Definition: sparsmat.cc:138
poly res
Definition: myNF.cc:322
void smSelectPR()
Definition: sparsmat.cc:1073
void smNewPivot()
Definition: sparsmat.cc:793
void smColDel()
Definition: sparsmat.cc:1549
smpoly piv
Definition: sparsmat.cc:146
void PrintS(const char *s)
Definition: reporter.cc:284
void smPivDel()
Definition: sparsmat.cc:1562
smpoly * m_act
Definition: sparsmat.cc:142
void smHElim()
Definition: sparsmat.cc:934
void sm1Elim()
Definition: sparsmat.cc:855
#define NULL
Definition: omList.c:10
void smInitPerm()
Definition: sparsmat.cc:1604
void smSign()
Definition: sparsmat.cc:1576
void smMultCol()
Definition: sparsmat.cc:1415
void smZeroElim()
Definition: sparsmat.cc:1190
polyrec * poly
Definition: hilb.h:10
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
void smFinalMult()
Definition: sparsmat.cc:1440

§ smFinalMult()

void sparse_mat::smFinalMult ( )
private

Definition at line 1440 of file sparsmat.cc.

1441 {
1442  smpoly a;
1443  poly ha;
1444  int i, f;
1445  int e = crd;
1446 
1447  for (i=act; i; i--)
1448  {
1449  a = m_act[i];
1450  do
1451  {
1452  f = a->e;
1453  if (f < e)
1454  {
1455  ha = SM_MULT(a->m, m_res[e]->m, m_res[f]->m, _R);
1456  p_Delete(&a->m,_R);
1457  if (f) SM_DIV(ha, m_res[f]->m, _R);
1458  a->m = ha;
1459  }
1460  if (normalize) p_Normalize(a->m, _R);
1461  a = a->n;
1462  } while (a != NULL);
1463  }
1464 }
const poly a
Definition: syzextra.cc:212
smpoly * m_res
Definition: sparsmat.cc:143
f
Definition: cfModGcd.cc:4022
sm_prec * smpoly
Definition: sparsmat.cc:51
int normalize
Definition: sparsmat.cc:138
int m
Definition: cfEzgcd.cc:119
int i
Definition: cfEzgcd.cc:123
smpoly * m_act
Definition: sparsmat.cc:142
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3633
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:843
#define NULL
Definition: omList.c:10
#define SM_MULT
Definition: sparsmat.h:23
#define SM_DIV
Definition: sparsmat.h:24
polyrec * poly
Definition: hilb.h:10

§ smGetAct()

smpoly* sparse_mat::smGetAct ( )
inline

Definition at line 177 of file sparsmat.cc.

177 { return m_act; }
smpoly * m_act
Definition: sparsmat.cc:142

§ smGetRed()

int sparse_mat::smGetRed ( )
inline

Definition at line 178 of file sparsmat.cc.

178 { return tored; }

§ smGetSign()

int sparse_mat::smGetSign ( )
inline

Definition at line 176 of file sparsmat.cc.

176 { return sign; }

§ smHElim()

void sparse_mat::smHElim ( )
private

Definition at line 934 of file sparsmat.cc.

935 {
936  poly hp = this->smMultPoly(piv);
937  poly gp = piv->m; // pivotelement
938  smpoly c = m_act[act]; // pivotcolumn
939  smpoly r = red; // row to reduce
940  smpoly res, a, b;
941  poly ha, hr, x, y;
942  int e, ip, ir, ia;
943 
944  if ((c == NULL) || (r == NULL))
945  {
946  while(r!=NULL) sm_ElemDelete(&r,_R);
947  p_Delete(&hp,_R);
948  return;
949  }
950  e = crd+1;
951  ip = piv->e;
952  do
953  {
954  a = m_act[r->pos];
955  res = dumm;
956  res->n = NULL;
957  b = c;
958  hr = r->m;
959  ir = r->e;
960  loop // combine the chains a and b: (hp,gp)*a(l) + hr*b(h)
961  {
962  if (a == NULL)
963  {
964  do
965  {
966  res = res->n = smElemCopy(b);
967  x = SM_MULT(b->m, hr, m_res[ir]->m,_R);
968  b = b->n;
969  if(ir) SM_DIV(x, m_res[ir]->m,_R);
970  res->m = x;
971  res->e = e;
972  res->f = sm_PolyWeight(res,_R);
973  } while (b != NULL);
974  break;
975  }
976  if (a->pos < b->pos)
977  {
978  res = res->n = a;
979  a = a->n;
980  }
981  else if (a->pos > b->pos)
982  {
983  res = res->n = smElemCopy(b);
984  x = SM_MULT(b->m, hr, m_res[ir]->m,_R);
985  b = b->n;
986  if(ir) SM_DIV(x, m_res[ir]->m,_R);
987  res->m = x;
988  res->e = e;
989  res->f = sm_PolyWeight(res,_R);
990  }
991  else
992  {
993  ha = a->m;
994  ia = a->e;
995  if (ir >= ia)
996  {
997  if (ir > ia)
998  {
999  x = SM_MULT(ha, m_res[ir]->m, m_res[ia]->m,_R);
1000  p_Delete(&ha,_R);
1001  ha = x;
1002  if (ia) SM_DIV(ha, m_res[ia]->m,_R);
1003  ia = ir;
1004  }
1005  x = SM_MULT(ha, gp, m_res[ia]->m,_R);
1006  p_Delete(&ha,_R);
1007  y = SM_MULT(b->m, hr, m_res[ia]->m,_R);
1008  }
1009  else if (ir >= ip)
1010  {
1011  if (ia < crd)
1012  {
1013  x = SM_MULT(ha, m_res[crd]->m, m_res[ia]->m,_R);
1014  p_Delete(&ha,_R);
1015  ha = x;
1016  SM_DIV(ha, m_res[ia]->m,_R);
1017  }
1018  y = hp;
1019  if(ir > ip)
1020  {
1021  y = SM_MULT(y, m_res[ir]->m, m_res[ip]->m,_R);
1022  if (ip) SM_DIV(y, m_res[ip]->m,_R);
1023  }
1024  ia = ir;
1025  x = SM_MULT(ha, y, m_res[ia]->m,_R);
1026  if (y != hp) p_Delete(&y,_R);
1027  p_Delete(&ha,_R);
1028  y = SM_MULT(b->m, hr, m_res[ia]->m,_R);
1029  }
1030  else
1031  {
1032  x = SM_MULT(hr, m_res[ia]->m, m_res[ir]->m,_R);
1033  if (ir) SM_DIV(x, m_res[ir]->m,_R);
1034  y = SM_MULT(b->m, x, m_res[ia]->m,_R);
1035  p_Delete(&x,_R);
1036  x = SM_MULT(ha, gp, m_res[ia]->m,_R);
1037  p_Delete(&ha,_R);
1038  }
1039  ha = p_Add_q(x, y,_R);
1040  if (ha != NULL)
1041  {
1042  if (ia) SM_DIV(ha, m_res[ia]->m,_R);
1043  a->m = ha;
1044  a->e = e;
1045  a->f = sm_PolyWeight(a,_R);
1046  res = res->n = a;
1047  a = a->n;
1048  }
1049  else
1050  {
1051  a->m = NULL;
1052  sm_ElemDelete(&a,_R);
1053  }
1054  b = b->n;
1055  }
1056  if (b == NULL)
1057  {
1058  res->n = a;
1059  break;
1060  }
1061  }
1062  m_act[r->pos] = dumm->n;
1063  sm_ElemDelete(&r,_R);
1064  } while (r != NULL);
1065  p_Delete(&hp,_R);
1066 }
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
const poly a
Definition: syzextra.cc:212
smpoly * m_res
Definition: sparsmat.cc:143
smpoly dumm
Definition: sparsmat.cc:147
loop
Definition: myNF.cc:98
sm_prec * smpoly
Definition: sparsmat.cc:51
smpoly red
Definition: sparsmat.cc:145
poly res
Definition: myNF.cc:322
const ring r
Definition: syzextra.cc:208
int m
Definition: cfEzgcd.cc:119
smpoly piv
Definition: sparsmat.cc:146
CanonicalForm gp
Definition: cfModGcd.cc:4043
smpoly * m_act
Definition: sparsmat.cc:142
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:843
#define NULL
Definition: omList.c:10
static smpoly smElemCopy(smpoly)
Definition: sparsmat.cc:2140
#define SM_MULT
Definition: sparsmat.h:23
Variable x
Definition: cfModGcd.cc:4023
#define SM_DIV
Definition: sparsmat.h:24
static float sm_PolyWeight(smpoly, const ring)
Definition: sparsmat.cc:2230
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:877
const poly b
Definition: syzextra.cc:213
poly smMultPoly(smpoly)
Definition: sparsmat.cc:1509
static void sm_ElemDelete(smpoly *, const ring)
Definition: sparsmat.cc:2131

§ smInitPerm()

void sparse_mat::smInitPerm ( )
private

Definition at line 1604 of file sparsmat.cc.

1605 {
1606  int i;
1607  for (i=act;i;i--) perm[i]=i;
1608 }
int i
Definition: cfEzgcd.cc:123
int * perm
Definition: sparsmat.cc:139

§ smMultCol()

void sparse_mat::smMultCol ( )
private

Definition at line 1415 of file sparsmat.cc.

1416 {
1417  smpoly a = m_act[act];
1418  int e = crd;
1419  poly ha;
1420  int f;
1421 
1422  while (a != NULL)
1423  {
1424  f = a->e;
1425  if (f < e)
1426  {
1427  ha = SM_MULT(a->m, m_res[e]->m, m_res[f]->m,_R);
1428  p_Delete(&a->m,_R);
1429  if (f) SM_DIV(ha, m_res[f]->m,_R);
1430  a->m = ha;
1431  if (normalize) p_Normalize(a->m,_R);
1432  }
1433  a = a->n;
1434  }
1435 }
const poly a
Definition: syzextra.cc:212
smpoly * m_res
Definition: sparsmat.cc:143
f
Definition: cfModGcd.cc:4022
sm_prec * smpoly
Definition: sparsmat.cc:51
int normalize
Definition: sparsmat.cc:138
int m
Definition: cfEzgcd.cc:119
smpoly * m_act
Definition: sparsmat.cc:142
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3633
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:843
#define NULL
Definition: omList.c:10
#define SM_MULT
Definition: sparsmat.h:23
#define SM_DIV
Definition: sparsmat.h:24
polyrec * poly
Definition: hilb.h:10

§ smMultPoly()

poly sparse_mat::smMultPoly ( smpoly  a)
private

Definition at line 1509 of file sparsmat.cc.

1510 {
1511  int f = a->e;
1512  poly r, h;
1513 
1514  if (f < crd)
1515  {
1516  h = r = a->m;
1517  h = SM_MULT(h, m_res[crd]->m, m_res[f]->m, _R);
1518  if (f) SM_DIV(h, m_res[f]->m, _R);
1519  a->m = h;
1520  if (normalize) p_Normalize(a->m,_R);
1521  a->f = sm_PolyWeight(a,_R);
1522  return r;
1523  }
1524  else
1525  return NULL;
1526 }
const poly a
Definition: syzextra.cc:212
smpoly * m_res
Definition: sparsmat.cc:143
f
Definition: cfModGcd.cc:4022
int normalize
Definition: sparsmat.cc:138
const ring r
Definition: syzextra.cc:208
int m
Definition: cfEzgcd.cc:119
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3633
#define NULL
Definition: omList.c:10
#define SM_MULT
Definition: sparsmat.h:23
#define SM_DIV
Definition: sparsmat.h:24
static float sm_PolyWeight(smpoly, const ring)
Definition: sparsmat.cc:2230
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978

§ smNewBareiss()

void sparse_mat::smNewBareiss ( int  x,
int  y 
)

Definition at line 605 of file sparsmat.cc.

606 {
607  if ((x > 0) && (x < nrows))
608  {
609  tored -= x;
610  this->smToredElim();
611  }
612  if (y < 1) y = 1;
613  if (act <= y)
614  {
615  this->smCopToRes();
616  return;
617  }
618  normalize = this->smCheckNormalize();
619  if (normalize) this->smNormalize();
620  this->smPivot();
621  this->smSelectPR();
622  this->sm1Elim();
623  crd++;
624  this->smColToRow();
625  act--;
626  this->smRowToCol();
627  this->smZeroElim();
628  if (tored != nrows)
629  this->smToredElim();
630  if (act <= y)
631  {
632  this->smFinalMult();
633  this->smCopToRes();
634  return;
635  }
636  loop
637  {
638  if (normalize) this->smNormalize();
639  this->smNewPivot();
640  this->smSelectPR();
641  this->smMultCol();
642  this->smHElim();
643  crd++;
644  this->smColToRow();
645  act--;
646  this->smRowToCol();
647  this->smZeroElim();
648  if (tored != nrows)
649  this->smToredElim();
650  if (act <= y)
651  {
652  if (TEST_OPT_PROT) PrintS(".\n");
653  this->smFinalMult();
654  this->smCopToRes();
655  return;
656  }
657  }
658 }
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
#define TEST_OPT_PROT
Definition: options.h:98
loop
Definition: myNF.cc:98
void smRowToCol()
Definition: sparsmat.cc:1157
void smNormalize()
Definition: sparsmat.cc:1489
void smPivot()
Definition: sparsmat.cc:698
int smCheckNormalize()
Definition: sparsmat.cc:1469
int normalize
Definition: sparsmat.cc:138
void smSelectPR()
Definition: sparsmat.cc:1073
void smNewPivot()
Definition: sparsmat.cc:793
void PrintS(const char *s)
Definition: reporter.cc:284
void smHElim()
Definition: sparsmat.cc:934
void sm1Elim()
Definition: sparsmat.cc:855
void smColToRow()
Definition: sparsmat.cc:1137
Variable x
Definition: cfModGcd.cc:4023
void smMultCol()
Definition: sparsmat.cc:1415
void smCopToRes()
Definition: sparsmat.cc:1259
void smToredElim()
Definition: sparsmat.cc:1220
void smZeroElim()
Definition: sparsmat.cc:1190
void smFinalMult()
Definition: sparsmat.cc:1440

§ smNewPivot()

void sparse_mat::smNewPivot ( )
private

Definition at line 793 of file sparsmat.cc.

794 {
795  float wopt = 1.0e30, hp = piv->f;
796  float wc, wr, wp, w;
797  smpoly a;
798  int i, copt, ropt, f, e = crd;
799 
800  this->smNewWeights();
801  for (i=act; i; i--)
802  {
803  a = m_act[i];
804  loop
805  {
806  if (a->pos > tored)
807  break;
808  w = a->f;
809  f = a->e;
810  if (f < e)
811  {
812  w *= hp;
813  if (f) w /= m_res[f]->f;
814  }
815  wc = wcl[i]-w;
816  wr = wrw[a->pos]-w;
817  if ((wr<0.25) || (wc<0.25)) // row or column with only one point
818  {
819  if (w<wopt)
820  {
821  wopt = w;
822  copt = i;
823  ropt = a->pos;
824  }
825  }
826  else // elimination
827  {
828  wp = w*(wpoints-wcl[i]-wr);
829  wp += wr*wc;
830  if (wp < wopt)
831  {
832  wopt = wp;
833  copt = i;
834  ropt = a->pos;
835  }
836  }
837  a = a->n;
838  if (a == NULL)
839  break;
840  }
841  }
842  rpiv = ropt;
843  cpiv = copt;
844  if (cpiv != act)
845  {
846  a = m_act[act];
847  m_act[act] = m_act[cpiv];
848  m_act[cpiv] = a;
849  }
850 }
const poly a
Definition: syzextra.cc:212
smpoly * m_res
Definition: sparsmat.cc:143
loop
Definition: myNF.cc:98
f
Definition: cfModGcd.cc:4022
float wpoints
Definition: sparsmat.cc:140
sm_prec * smpoly
Definition: sparsmat.cc:51
float * wrw
Definition: sparsmat.cc:141
smpoly piv
Definition: sparsmat.cc:146
int i
Definition: cfEzgcd.cc:123
smpoly * m_act
Definition: sparsmat.cc:142
float * wcl
Definition: sparsmat.cc:141
#define NULL
Definition: omList.c:10
const CanonicalForm & w
Definition: facAbsFact.cc:55
void smNewWeights()
Definition: sparsmat.cc:755

§ smNewWeights()

void sparse_mat::smNewWeights ( )
private

Definition at line 755 of file sparsmat.cc.

756 {
757  float wc, wp, w, hp = piv->f;
758  smpoly a;
759  int i, f, e = crd;
760 
761  wp = 0.0;
762  for (i=tored; i; i--) wrw[i] = 0.0; // ???
763  for (i=act; i; i--)
764  {
765  wc = 0.0;
766  a = m_act[i];
767  loop
768  {
769  if (a->pos > tored)
770  break;
771  w = a->f;
772  f = a->e;
773  if (f < e)
774  {
775  w *= hp;
776  if (f) w /= m_res[f]->f;
777  }
778  wc += w;
779  wrw[a->pos] += w;
780  a = a->n;
781  if (a == NULL)
782  break;
783  }
784  wp += wc;
785  wcl[i] = wc;
786  }
787  wpoints = wp;
788 }
const poly a
Definition: syzextra.cc:212
smpoly * m_res
Definition: sparsmat.cc:143
loop
Definition: myNF.cc:98
f
Definition: cfModGcd.cc:4022
float wpoints
Definition: sparsmat.cc:140
sm_prec * smpoly
Definition: sparsmat.cc:51
float * wrw
Definition: sparsmat.cc:141
smpoly piv
Definition: sparsmat.cc:146
int i
Definition: cfEzgcd.cc:123
smpoly * m_act
Definition: sparsmat.cc:142
float * wcl
Definition: sparsmat.cc:141
#define NULL
Definition: omList.c:10
const CanonicalForm & w
Definition: facAbsFact.cc:55

§ smNormalize()

void sparse_mat::smNormalize ( )
private

Definition at line 1489 of file sparsmat.cc.

1490 {
1491  smpoly a;
1492  int i;
1493  int e = crd;
1494 
1495  for (i=act; i; i--)
1496  {
1497  a = m_act[i];
1498  do
1499  {
1500  if (e == a->e) p_Normalize(a->m,_R);
1501  a = a->n;
1502  } while (a != NULL);
1503  }
1504 }
const poly a
Definition: syzextra.cc:212
sm_prec * smpoly
Definition: sparsmat.cc:51
int i
Definition: cfEzgcd.cc:123
smpoly * m_act
Definition: sparsmat.cc:142
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3633
#define NULL
Definition: omList.c:10

§ smPivDel()

void sparse_mat::smPivDel ( )
private

Definition at line 1562 of file sparsmat.cc.

1563 {
1564  int i=crd;
1565 
1566  while (i != 0)
1567  {
1568  sm_ElemDelete(&m_res[i],_R);
1569  i--;
1570  }
1571 }
smpoly * m_res
Definition: sparsmat.cc:143
int i
Definition: cfEzgcd.cc:123
static void sm_ElemDelete(smpoly *, const ring)
Definition: sparsmat.cc:2131

§ smPivot()

void sparse_mat::smPivot ( )
private

Definition at line 698 of file sparsmat.cc.

699 {
700  float wopt = 1.0e30;
701  float wc, wr, wp, w;
702  smpoly a;
703  int i, copt, ropt;
704 
705  this->smWeights();
706  for (i=act; i; i--)
707  {
708  a = m_act[i];
709  loop
710  {
711  if (a->pos > tored)
712  break;
713  w = a->f;
714  wc = wcl[i]-w;
715  wr = wrw[a->pos]-w;
716  if ((wr<0.25) || (wc<0.25)) // row or column with only one point
717  {
718  if (w<wopt)
719  {
720  wopt = w;
721  copt = i;
722  ropt = a->pos;
723  }
724  }
725  else // elimination
726  {
727  wp = w*(wpoints-wcl[i]-wr);
728  wp += wr*wc;
729  if (wp < wopt)
730  {
731  wopt = wp;
732  copt = i;
733  ropt = a->pos;
734  }
735  }
736  a = a->n;
737  if (a == NULL)
738  break;
739  }
740  }
741  rpiv = ropt;
742  cpiv = copt;
743  if (cpiv != act)
744  {
745  a = m_act[act];
746  m_act[act] = m_act[cpiv];
747  m_act[cpiv] = a;
748  }
749 }
const poly a
Definition: syzextra.cc:212
void smWeights()
Definition: sparsmat.cc:666
loop
Definition: myNF.cc:98
float wpoints
Definition: sparsmat.cc:140
sm_prec * smpoly
Definition: sparsmat.cc:51
float * wrw
Definition: sparsmat.cc:141
int i
Definition: cfEzgcd.cc:123
smpoly * m_act
Definition: sparsmat.cc:142
float * wcl
Definition: sparsmat.cc:141
#define NULL
Definition: omList.c:10
const CanonicalForm & w
Definition: facAbsFact.cc:55

§ smRes2Mod()

ideal sparse_mat::smRes2Mod ( )

Definition at line 504 of file sparsmat.cc.

505 {
506  ideal res = idInit(crd, crd);
507  int i;
508 
509  for (i=crd; i; i--)
510  {
511  res->m[i-1] = sm_Smpoly2Poly(m_res[i],_R);
512  res->rank=si_max(res->rank, p_MaxComp(res->m[i-1],_R));
513  }
514  return res;
515 }
static poly sm_Smpoly2Poly(smpoly, const ring)
Definition: sparsmat.cc:2189
smpoly * m_res
Definition: sparsmat.cc:143
poly res
Definition: myNF.cc:322
static int si_max(const int a, const int b)
Definition: auxiliary.h:120
int i
Definition: cfEzgcd.cc:123
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
static long p_MaxComp(poly p, ring lmRing, ring tailRing)
Definition: p_polys.h:287

§ smRowToCol()

void sparse_mat::smRowToCol ( )
private

Definition at line 1157 of file sparsmat.cc.

1158 {
1159  smpoly r = m_row[rpiv];
1160  smpoly a, ap, h;
1161 
1162  m_row[rpiv] = NULL;
1163  perm[crd] = rpiv;
1164  piv->pos = crd;
1165  m_res[crd] = piv;
1166  while (r != NULL)
1167  {
1168  ap = m_res[r->pos];
1169  loop
1170  {
1171  a = ap->n;
1172  if (a == NULL)
1173  {
1174  ap->n = h = r;
1175  r = r->n;
1176  h->n = a;
1177  h->pos = crd;
1178  break;
1179  }
1180  ap = a;
1181  }
1182  }
1183 }
const poly a
Definition: syzextra.cc:212
smpoly * m_res
Definition: sparsmat.cc:143
loop
Definition: myNF.cc:98
sm_prec * smpoly
Definition: sparsmat.cc:51
const ring r
Definition: syzextra.cc:208
smpoly piv
Definition: sparsmat.cc:146
int * perm
Definition: sparsmat.cc:139
smpoly * m_row
Definition: sparsmat.cc:144
#define NULL
Definition: omList.c:10
static Poly * h
Definition: janet.cc:978

§ smSelectPR()

void sparse_mat::smSelectPR ( )
private

Definition at line 1073 of file sparsmat.cc.

1074 {
1075  smpoly b = dumm;
1076  smpoly a, ap;
1077  int i;
1078 
1079  if (TEST_OPT_PROT)
1080  {
1081  if ((crd+1)%10)
1082  PrintS(".");
1083  else
1084  PrintS(".\n");
1085  }
1086  a = m_act[act];
1087  if (a->pos < rpiv)
1088  {
1089  do
1090  {
1091  ap = a;
1092  a = a->n;
1093  } while (a->pos < rpiv);
1094  ap->n = a->n;
1095  }
1096  else
1097  m_act[act] = a->n;
1098  piv = a;
1099  a->n = NULL;
1100  for (i=1; i<act; i++)
1101  {
1102  a = m_act[i];
1103  if (a->pos < rpiv)
1104  {
1105  loop
1106  {
1107  ap = a;
1108  a = a->n;
1109  if ((a == NULL) || (a->pos > rpiv))
1110  break;
1111  if (a->pos == rpiv)
1112  {
1113  ap->n = a->n;
1114  a->m = p_Neg(a->m,_R);
1115  b = b->n = a;
1116  b->pos = i;
1117  break;
1118  }
1119  }
1120  }
1121  else if (a->pos == rpiv)
1122  {
1123  m_act[i] = a->n;
1124  a->m = p_Neg(a->m,_R);
1125  b = b->n = a;
1126  b->pos = i;
1127  }
1128  }
1129  b->n = NULL;
1130  red = dumm->n;
1131 }
const poly a
Definition: syzextra.cc:212
smpoly dumm
Definition: sparsmat.cc:147
#define TEST_OPT_PROT
Definition: options.h:98
loop
Definition: myNF.cc:98
sm_prec * smpoly
Definition: sparsmat.cc:51
smpoly red
Definition: sparsmat.cc:145
smpoly piv
Definition: sparsmat.cc:146
int i
Definition: cfEzgcd.cc:123
void PrintS(const char *s)
Definition: reporter.cc:284
smpoly * m_act
Definition: sparsmat.cc:142
#define NULL
Definition: omList.c:10
static poly p_Neg(poly p, const ring r)
Definition: p_polys.h:1013
const poly b
Definition: syzextra.cc:213

§ smSign()

void sparse_mat::smSign ( )
private

Definition at line 1576 of file sparsmat.cc.

1577 {
1578  int j,i;
1579  if (act > 2)
1580  {
1581  if (cpiv!=act) sign=-sign;
1582  if ((act%2)==0) sign=-sign;
1583  i=1;
1584  j=perm[1];
1585  while(j<rpiv)
1586  {
1587  sign=-sign;
1588  i++;
1589  j=perm[i];
1590  }
1591  while(perm[i]!=0)
1592  {
1593  perm[i]=perm[i+1];
1594  i++;
1595  }
1596  }
1597  else
1598  {
1599  if (cpiv!=1) sign=-sign;
1600  if (rpiv!=perm[1]) sign=-sign;
1601  }
1602 }
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
int * perm
Definition: sparsmat.cc:139

§ smSparseHomog()

void sparse_mat::smSparseHomog ( )
private

§ smToIntvec()

void sparse_mat::smToIntvec ( intvec v)

Definition at line 520 of file sparsmat.cc.

521 {
522  int i;
523 
524  for (i=v->rows()-1; i>=0; i--)
525  (*v)[i] = perm[i+1];
526 }
int rows() const
Definition: intvec.h:88
int i
Definition: cfEzgcd.cc:123
int * perm
Definition: sparsmat.cc:139

§ smToredElim()

void sparse_mat::smToredElim ( )
private

Definition at line 1220 of file sparsmat.cc.

1221 {
1222  int i = 0;
1223  int j;
1224 
1225  loop
1226  {
1227  i++;
1228  if (i > act) return;
1229  if (m_act[i]->pos > tored)
1230  {
1231  m_res[inred] = m_act[i];
1232  inred--;
1233  break;
1234  }
1235  }
1236  j = i;
1237  loop
1238  {
1239  j++;
1240  if (j > act) break;
1241  if (m_act[j]->pos > tored)
1242  {
1243  m_res[inred] = m_act[j];
1244  inred--;
1245  }
1246  else
1247  {
1248  m_act[i] = m_act[j];
1249  i++;
1250  }
1251  }
1252  act -= (j-i);
1253  sign = 0;
1254 }
smpoly * m_res
Definition: sparsmat.cc:143
loop
Definition: myNF.cc:98
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
smpoly * m_act
Definition: sparsmat.cc:142

§ smWeights()

void sparse_mat::smWeights ( )
private

Definition at line 666 of file sparsmat.cc.

667 {
668  float wc, wp, w;
669  smpoly a;
670  int i;
671 
672  wp = 0.0;
673  for (i=tored; i; i--) wrw[i] = 0.0; // ???
674  for (i=act; i; i--)
675  {
676  wc = 0.0;
677  a = m_act[i];
678  loop
679  {
680  if (a->pos > tored)
681  break;
682  w = a->f = sm_PolyWeight(a,_R);
683  wc += w;
684  wrw[a->pos] += w;
685  a = a->n;
686  if (a == NULL)
687  break;
688  }
689  wp += wc;
690  wcl[i] = wc;
691  }
692  wpoints = wp;
693 }
const poly a
Definition: syzextra.cc:212
loop
Definition: myNF.cc:98
float wpoints
Definition: sparsmat.cc:140
sm_prec * smpoly
Definition: sparsmat.cc:51
float * wrw
Definition: sparsmat.cc:141
int i
Definition: cfEzgcd.cc:123
smpoly * m_act
Definition: sparsmat.cc:142
float * wcl
Definition: sparsmat.cc:141
#define NULL
Definition: omList.c:10
const CanonicalForm & w
Definition: facAbsFact.cc:55
static float sm_PolyWeight(smpoly, const ring)
Definition: sparsmat.cc:2230

§ smZeroElim()

void sparse_mat::smZeroElim ( )
private

Definition at line 1190 of file sparsmat.cc.

1191 {
1192  int i = 0;
1193  int j;
1194 
1195  loop
1196  {
1197  i++;
1198  if (i > act) return;
1199  if (m_act[i] == NULL) break;
1200  }
1201  j = i;
1202  loop
1203  {
1204  j++;
1205  if (j > act) break;
1206  if (m_act[j] != NULL)
1207  {
1208  m_act[i] = m_act[j];
1209  i++;
1210  }
1211  }
1212  act -= (j-i);
1213  sign = 0;
1214 }
loop
Definition: myNF.cc:98
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
smpoly * m_act
Definition: sparsmat.cc:142
#define NULL
Definition: omList.c:10

Field Documentation

§ _R

ring sparse_mat::_R
private

Definition at line 148 of file sparsmat.cc.

§ act

int sparse_mat::act
private

Definition at line 133 of file sparsmat.cc.

§ cpiv

int sparse_mat::cpiv
private

Definition at line 137 of file sparsmat.cc.

§ crd

int sparse_mat::crd
private

Definition at line 134 of file sparsmat.cc.

§ dumm

smpoly sparse_mat::dumm
private

Definition at line 147 of file sparsmat.cc.

§ inred

int sparse_mat::inred
private

Definition at line 136 of file sparsmat.cc.

§ m_act

smpoly* sparse_mat::m_act
private

Definition at line 142 of file sparsmat.cc.

§ m_res

smpoly* sparse_mat::m_res
private

Definition at line 143 of file sparsmat.cc.

§ m_row

smpoly* sparse_mat::m_row
private

Definition at line 144 of file sparsmat.cc.

§ ncols

int sparse_mat::ncols
private

Definition at line 131 of file sparsmat.cc.

§ normalize

int sparse_mat::normalize
private

Definition at line 138 of file sparsmat.cc.

§ nrows

int sparse_mat::nrows
private

Definition at line 131 of file sparsmat.cc.

§ oldpiv

smpoly sparse_mat::oldpiv
private

Definition at line 146 of file sparsmat.cc.

§ perm

int* sparse_mat::perm
private

Definition at line 139 of file sparsmat.cc.

§ piv

smpoly sparse_mat::piv
private

Definition at line 146 of file sparsmat.cc.

§ red

smpoly sparse_mat::red
private

Definition at line 145 of file sparsmat.cc.

§ rpiv

int sparse_mat::rpiv
private

Definition at line 137 of file sparsmat.cc.

§ sign

int sparse_mat::sign
private

Definition at line 132 of file sparsmat.cc.

§ tored

int sparse_mat::tored
private

Definition at line 135 of file sparsmat.cc.

§ wcl

float * sparse_mat::wcl
private

Definition at line 141 of file sparsmat.cc.

§ wpoints

float sparse_mat::wpoints
private

Definition at line 140 of file sparsmat.cc.

§ wrw

float* sparse_mat::wrw
private

Definition at line 141 of file sparsmat.cc.


The documentation for this class was generated from the following file: