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 130 of file sparsmat.cc.

Constructor & Destructor Documentation

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

Definition at line 443 of file sparsmat.cc.

444 {
445  int i;
446  poly* pmat;
447  _R=RR;
448 
449  ncols = smat->ncols;
450  nrows = id_RankFreeModule(smat,RR);
451  if (nrows <= 0)
452  {
453  m_act = NULL;
454  return;
455  }
456  sign = 1;
457  inred = act = ncols;
458  crd = 0;
459  tored = nrows; // without border
460  i = tored+1;
461  perm = (int *)omAlloc(sizeof(int)*(i+1));
462  perm[i] = 0;
463  m_row = (smpoly *)omAlloc0(sizeof(smpoly)*i);
464  wrw = (float *)omAlloc(sizeof(float)*i);
465  i = ncols+1;
466  wcl = (float *)omAlloc(sizeof(float)*i);
467  m_act = (smpoly *)omAlloc(sizeof(smpoly)*i);
468  m_res = (smpoly *)omAlloc0(sizeof(smpoly)*i);
471  m_res[0]->m = NULL;
472  pmat = smat->m;
473  for(i=ncols; i; i--)
474  {
475  m_act[i] = sm_Poly2Smpoly(pmat[i-1], RR);
476  pmat[i-1] = NULL;
477  }
478  this->smZeroElim();
479  oldpiv = NULL;
480 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
smpoly * m_res
Definition: sparsmat.cc:144
smpoly dumm
Definition: sparsmat.cc:148
omBin smprec_bin
Definition: sparsmat.cc:80
sm_prec * smpoly
Definition: sparsmat.cc:52
#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:2153
float * wrw
Definition: sparsmat.cc:142
int i
Definition: cfEzgcd.cc:123
int * perm
Definition: sparsmat.cc:140
smpoly * m_act
Definition: sparsmat.cc:143
smpoly * m_row
Definition: sparsmat.cc:145
float * wcl
Definition: sparsmat.cc:142
#define NULL
Definition: omList.c:10
void smZeroElim()
Definition: sparsmat.cc:1191
polyrec * poly
Definition: hilb.h:10
smpoly oldpiv
Definition: sparsmat.cc:147
#define omAlloc0(size)
Definition: omAllocDecl.h:211
sparse_mat::~sparse_mat ( )

Definition at line 485 of file sparsmat.cc.

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

Member Function Documentation

void sparse_mat::sm1Elim ( )
private

Definition at line 856 of file sparsmat.cc.

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

Definition at line 1532 of file sparsmat.cc.

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

Definition at line 1470 of file sparsmat.cc.

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

Definition at line 1550 of file sparsmat.cc.

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

Definition at line 1138 of file sparsmat.cc.

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

Definition at line 1260 of file sparsmat.cc.

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

Definition at line 532 of file sparsmat.cc.

533 {
534  poly res = NULL;
535 
536  if (sign == 0)
537  {
538  this->smActDel();
539  return NULL;
540  }
541  if (act < 2)
542  {
543  if (act != 0) res = m_act[1]->m;
544  omFreeBin((void *)m_act[1], smprec_bin);
545  return res;
546  }
547  normalize = 0;
548  this->smInitPerm();
549  this->smPivot();
550  this->smSign();
551  this->smSelectPR();
552  this->sm1Elim();
553  crd++;
554  m_res[crd] = piv;
555  this->smColDel();
556  act--;
557  this->smZeroElim();
558  if (sign == 0)
559  {
560  this->smActDel();
561  return NULL;
562  }
563  if (act < 2)
564  {
565  this->smFinalMult();
566  this->smPivDel();
567  if (act != 0) res = m_act[1]->m;
568  omFreeBin((void *)m_act[1], smprec_bin);
569  return res;
570  }
571  loop
572  {
573  this->smNewPivot();
574  this->smSign();
575  this->smSelectPR();
576  this->smMultCol();
577  this->smHElim();
578  crd++;
579  m_res[crd] = piv;
580  this->smColDel();
581  act--;
582  this->smZeroElim();
583  if (sign == 0)
584  {
585  this->smPivDel();
586  this->smActDel();
587  return NULL;
588  }
589  if (act < 2)
590  {
591  if (TEST_OPT_PROT) PrintS(".\n");
592  this->smFinalMult();
593  this->smPivDel();
594  if (act != 0) res = m_act[1]->m;
595  omFreeBin((void *)m_act[1], smprec_bin);
596  return res;
597  }
598  }
599 }
smpoly * m_res
Definition: sparsmat.cc:144
#define TEST_OPT_PROT
Definition: options.h:98
loop
Definition: myNF.cc:98
void smPivot()
Definition: sparsmat.cc:699
omBin smprec_bin
Definition: sparsmat.cc:80
void smActDel()
Definition: sparsmat.cc:1532
int normalize
Definition: sparsmat.cc:139
poly res
Definition: myNF.cc:322
void smSelectPR()
Definition: sparsmat.cc:1074
void smNewPivot()
Definition: sparsmat.cc:794
void smColDel()
Definition: sparsmat.cc:1550
smpoly piv
Definition: sparsmat.cc:147
void PrintS(const char *s)
Definition: reporter.cc:294
void smPivDel()
Definition: sparsmat.cc:1563
smpoly * m_act
Definition: sparsmat.cc:143
void smHElim()
Definition: sparsmat.cc:935
void sm1Elim()
Definition: sparsmat.cc:856
#define NULL
Definition: omList.c:10
void smInitPerm()
Definition: sparsmat.cc:1605
void smSign()
Definition: sparsmat.cc:1577
void smMultCol()
Definition: sparsmat.cc:1416
void smZeroElim()
Definition: sparsmat.cc:1191
polyrec * poly
Definition: hilb.h:10
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
void smFinalMult()
Definition: sparsmat.cc:1441
void sparse_mat::smFinalMult ( )
private

Definition at line 1441 of file sparsmat.cc.

1442 {
1443  smpoly a;
1444  poly ha;
1445  int i, f;
1446  int e = crd;
1447 
1448  for (i=act; i; i--)
1449  {
1450  a = m_act[i];
1451  do
1452  {
1453  f = a->e;
1454  if (f < e)
1455  {
1456  ha = SM_MULT(a->m, m_res[e]->m, m_res[f]->m, _R);
1457  p_Delete(&a->m,_R);
1458  if (f) SM_DIV(ha, m_res[f]->m, _R);
1459  a->m = ha;
1460  }
1461  if (normalize) p_Normalize(a->m, _R);
1462  a = a->n;
1463  } while (a != NULL);
1464  }
1465 }
const poly a
Definition: syzextra.cc:212
smpoly * m_res
Definition: sparsmat.cc:144
sm_prec * smpoly
Definition: sparsmat.cc:52
int normalize
Definition: sparsmat.cc:139
int m
Definition: cfEzgcd.cc:119
FILE * f
Definition: checklibs.c:7
int i
Definition: cfEzgcd.cc:123
smpoly * m_act
Definition: sparsmat.cc:143
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3632
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:849
#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
smpoly* sparse_mat::smGetAct ( )
inline

Definition at line 178 of file sparsmat.cc.

178 { return m_act; }
smpoly * m_act
Definition: sparsmat.cc:143
int sparse_mat::smGetRed ( )
inline

Definition at line 179 of file sparsmat.cc.

179 { return tored; }
int sparse_mat::smGetSign ( )
inline

Definition at line 177 of file sparsmat.cc.

177 { return sign; }
void sparse_mat::smHElim ( )
private

Definition at line 935 of file sparsmat.cc.

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

Definition at line 1605 of file sparsmat.cc.

1606 {
1607  int i;
1608  for (i=act;i;i--) perm[i]=i;
1609 }
int i
Definition: cfEzgcd.cc:123
int * perm
Definition: sparsmat.cc:140
void sparse_mat::smMultCol ( )
private

Definition at line 1416 of file sparsmat.cc.

1417 {
1418  smpoly a = m_act[act];
1419  int e = crd;
1420  poly ha;
1421  int f;
1422 
1423  while (a != NULL)
1424  {
1425  f = a->e;
1426  if (f < e)
1427  {
1428  ha = SM_MULT(a->m, m_res[e]->m, m_res[f]->m,_R);
1429  p_Delete(&a->m,_R);
1430  if (f) SM_DIV(ha, m_res[f]->m,_R);
1431  a->m = ha;
1432  if (normalize) p_Normalize(a->m,_R);
1433  }
1434  a = a->n;
1435  }
1436 }
const poly a
Definition: syzextra.cc:212
smpoly * m_res
Definition: sparsmat.cc:144
sm_prec * smpoly
Definition: sparsmat.cc:52
int normalize
Definition: sparsmat.cc:139
int m
Definition: cfEzgcd.cc:119
FILE * f
Definition: checklibs.c:7
smpoly * m_act
Definition: sparsmat.cc:143
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3632
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:849
#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
poly sparse_mat::smMultPoly ( smpoly  a)
private

Definition at line 1510 of file sparsmat.cc.

1511 {
1512  int f = a->e;
1513  poly r, h;
1514 
1515  if (f < crd)
1516  {
1517  h = r = a->m;
1518  h = SM_MULT(h, m_res[crd]->m, m_res[f]->m, _R);
1519  if (f) SM_DIV(h, m_res[f]->m, _R);
1520  a->m = h;
1521  if (normalize) p_Normalize(a->m,_R);
1522  a->f = sm_PolyWeight(a,_R);
1523  return r;
1524  }
1525  else
1526  return NULL;
1527 }
const poly a
Definition: syzextra.cc:212
smpoly * m_res
Definition: sparsmat.cc:144
int normalize
Definition: sparsmat.cc:139
const ring r
Definition: syzextra.cc:208
int m
Definition: cfEzgcd.cc:119
FILE * f
Definition: checklibs.c:7
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3632
#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:2231
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
void sparse_mat::smNewBareiss ( int  x,
int  y 
)

Definition at line 606 of file sparsmat.cc.

607 {
608  if ((x > 0) && (x < nrows))
609  {
610  tored -= x;
611  this->smToredElim();
612  }
613  if (y < 1) y = 1;
614  if (act <= y)
615  {
616  this->smCopToRes();
617  return;
618  }
619  normalize = this->smCheckNormalize();
620  if (normalize) this->smNormalize();
621  this->smPivot();
622  this->smSelectPR();
623  this->sm1Elim();
624  crd++;
625  this->smColToRow();
626  act--;
627  this->smRowToCol();
628  this->smZeroElim();
629  if (tored != nrows)
630  this->smToredElim();
631  if (act <= y)
632  {
633  this->smFinalMult();
634  this->smCopToRes();
635  return;
636  }
637  loop
638  {
639  if (normalize) this->smNormalize();
640  this->smNewPivot();
641  this->smSelectPR();
642  this->smMultCol();
643  this->smHElim();
644  crd++;
645  this->smColToRow();
646  act--;
647  this->smRowToCol();
648  this->smZeroElim();
649  if (tored != nrows)
650  this->smToredElim();
651  if (act <= y)
652  {
653  if (TEST_OPT_PROT) PrintS(".\n");
654  this->smFinalMult();
655  this->smCopToRes();
656  return;
657  }
658  }
659 }
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:1158
void smNormalize()
Definition: sparsmat.cc:1490
void smPivot()
Definition: sparsmat.cc:699
int smCheckNormalize()
Definition: sparsmat.cc:1470
int normalize
Definition: sparsmat.cc:139
void smSelectPR()
Definition: sparsmat.cc:1074
void smNewPivot()
Definition: sparsmat.cc:794
void PrintS(const char *s)
Definition: reporter.cc:294
void smHElim()
Definition: sparsmat.cc:935
void sm1Elim()
Definition: sparsmat.cc:856
void smColToRow()
Definition: sparsmat.cc:1138
Variable x
Definition: cfModGcd.cc:4023
void smMultCol()
Definition: sparsmat.cc:1416
void smCopToRes()
Definition: sparsmat.cc:1260
void smToredElim()
Definition: sparsmat.cc:1221
void smZeroElim()
Definition: sparsmat.cc:1191
void smFinalMult()
Definition: sparsmat.cc:1441
void sparse_mat::smNewPivot ( )
private

Definition at line 794 of file sparsmat.cc.

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

Definition at line 756 of file sparsmat.cc.

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

Definition at line 1490 of file sparsmat.cc.

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

Definition at line 1563 of file sparsmat.cc.

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

Definition at line 699 of file sparsmat.cc.

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

Definition at line 505 of file sparsmat.cc.

506 {
507  ideal res = idInit(crd, crd);
508  int i;
509 
510  for (i=crd; i; i--)
511  {
512  res->m[i-1] = sm_Smpoly2Poly(m_res[i],_R);
513  res->rank=si_max(res->rank, p_MaxComp(res->m[i-1],_R));
514  }
515  return res;
516 }
static poly sm_Smpoly2Poly(smpoly, const ring)
Definition: sparsmat.cc:2190
smpoly * m_res
Definition: sparsmat.cc:144
poly res
Definition: myNF.cc:322
static int si_max(const int a, const int b)
Definition: auxiliary.h:166
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
void sparse_mat::smRowToCol ( )
private

Definition at line 1158 of file sparsmat.cc.

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

Definition at line 1074 of file sparsmat.cc.

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

Definition at line 1577 of file sparsmat.cc.

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

Definition at line 521 of file sparsmat.cc.

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

Definition at line 1221 of file sparsmat.cc.

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

Definition at line 667 of file sparsmat.cc.

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

Definition at line 1191 of file sparsmat.cc.

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

Field Documentation

ring sparse_mat::_R
private

Definition at line 149 of file sparsmat.cc.

int sparse_mat::act
private

Definition at line 134 of file sparsmat.cc.

int sparse_mat::cpiv
private

Definition at line 138 of file sparsmat.cc.

int sparse_mat::crd
private

Definition at line 135 of file sparsmat.cc.

smpoly sparse_mat::dumm
private

Definition at line 148 of file sparsmat.cc.

int sparse_mat::inred
private

Definition at line 137 of file sparsmat.cc.

smpoly* sparse_mat::m_act
private

Definition at line 143 of file sparsmat.cc.

smpoly* sparse_mat::m_res
private

Definition at line 144 of file sparsmat.cc.

smpoly* sparse_mat::m_row
private

Definition at line 145 of file sparsmat.cc.

int sparse_mat::ncols
private

Definition at line 132 of file sparsmat.cc.

int sparse_mat::normalize
private

Definition at line 139 of file sparsmat.cc.

int sparse_mat::nrows
private

Definition at line 132 of file sparsmat.cc.

smpoly sparse_mat::oldpiv
private

Definition at line 147 of file sparsmat.cc.

int* sparse_mat::perm
private

Definition at line 140 of file sparsmat.cc.

smpoly sparse_mat::piv
private

Definition at line 147 of file sparsmat.cc.

smpoly sparse_mat::red
private

Definition at line 146 of file sparsmat.cc.

int sparse_mat::rpiv
private

Definition at line 138 of file sparsmat.cc.

int sparse_mat::sign
private

Definition at line 133 of file sparsmat.cc.

int sparse_mat::tored
private

Definition at line 136 of file sparsmat.cc.

float * sparse_mat::wcl
private

Definition at line 142 of file sparsmat.cc.

float sparse_mat::wpoints
private

Definition at line 141 of file sparsmat.cc.

float* sparse_mat::wrw
private

Definition at line 142 of file sparsmat.cc.


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