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:2150
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:1188
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 853 of file sparsmat.cc.

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

Definition at line 1529 of file sparsmat.cc.

1530 {
1531  smpoly a;
1532  int i;
1533 
1534  for (i=act; i; i--)
1535  {
1536  a = m_act[i];
1537  do
1538  {
1539  sm_ElemDelete(&a,_R);
1540  } while (a != NULL);
1541  }
1542 }
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:2129
int sparse_mat::smCheckNormalize ( )
private

Definition at line 1467 of file sparsmat.cc.

1468 {
1469  int i;
1470  smpoly a;
1471 
1472  for (i=act; i; i--)
1473  {
1474  a = m_act[i];
1475  do
1476  {
1477  if(sm_HaveDenom(a->m,_R)) return 1;
1478  a = a->n;
1479  } while (a != NULL);
1480  }
1481  return 0;
1482 }
const poly a
Definition: syzextra.cc:212
sm_prec * smpoly
Definition: sparsmat.cc:52
static BOOLEAN sm_HaveDenom(poly, const ring)
Definition: sparsmat.cc:2257
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 1547 of file sparsmat.cc.

1548 {
1549  smpoly a = m_act[act];
1550 
1551  while (a != NULL)
1552  {
1553  sm_ElemDelete(&a,_R);
1554  }
1555 }
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:2129
void sparse_mat::smColToRow ( )
private

Definition at line 1135 of file sparsmat.cc.

1136 {
1137  smpoly c = m_act[act];
1138  smpoly h;
1139 
1140  while (c != NULL)
1141  {
1142  h = c;
1143  c = c->n;
1144  h->n = m_row[h->pos];
1145  m_row[h->pos] = h;
1146  h->pos = crd;
1147  }
1148 }
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 1257 of file sparsmat.cc.

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

530 {
531  poly res = NULL;
532 
533  if (sign == 0)
534  {
535  this->smActDel();
536  return NULL;
537  }
538  if (act < 2)
539  {
540  if (act != 0) res = m_act[1]->m;
541  omFreeBin((void *)m_act[1], smprec_bin);
542  return res;
543  }
544  normalize = 0;
545  this->smInitPerm();
546  this->smPivot();
547  this->smSign();
548  this->smSelectPR();
549  this->sm1Elim();
550  crd++;
551  m_res[crd] = piv;
552  this->smColDel();
553  act--;
554  this->smZeroElim();
555  if (sign == 0)
556  {
557  this->smActDel();
558  return NULL;
559  }
560  if (act < 2)
561  {
562  this->smFinalMult();
563  this->smPivDel();
564  if (act != 0) res = m_act[1]->m;
565  omFreeBin((void *)m_act[1], smprec_bin);
566  return res;
567  }
568  loop
569  {
570  this->smNewPivot();
571  this->smSign();
572  this->smSelectPR();
573  this->smMultCol();
574  this->smHElim();
575  crd++;
576  m_res[crd] = piv;
577  this->smColDel();
578  act--;
579  this->smZeroElim();
580  if (sign == 0)
581  {
582  this->smPivDel();
583  this->smActDel();
584  return NULL;
585  }
586  if (act < 2)
587  {
588  if (TEST_OPT_PROT) PrintS(".\n");
589  this->smFinalMult();
590  this->smPivDel();
591  if (act != 0) res = m_act[1]->m;
592  omFreeBin((void *)m_act[1], smprec_bin);
593  return res;
594  }
595  }
596 }
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:696
omBin smprec_bin
Definition: sparsmat.cc:80
void smActDel()
Definition: sparsmat.cc:1529
int normalize
Definition: sparsmat.cc:139
poly res
Definition: myNF.cc:322
void smSelectPR()
Definition: sparsmat.cc:1071
void smNewPivot()
Definition: sparsmat.cc:791
void smColDel()
Definition: sparsmat.cc:1547
smpoly piv
Definition: sparsmat.cc:147
void PrintS(const char *s)
Definition: reporter.cc:294
void smPivDel()
Definition: sparsmat.cc:1560
smpoly * m_act
Definition: sparsmat.cc:143
void smHElim()
Definition: sparsmat.cc:932
void sm1Elim()
Definition: sparsmat.cc:853
#define NULL
Definition: omList.c:10
void smInitPerm()
Definition: sparsmat.cc:1602
void smSign()
Definition: sparsmat.cc:1574
void smMultCol()
Definition: sparsmat.cc:1413
void smZeroElim()
Definition: sparsmat.cc:1188
polyrec * poly
Definition: hilb.h:10
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
void smFinalMult()
Definition: sparsmat.cc:1438
void sparse_mat::smFinalMult ( )
private

Definition at line 1438 of file sparsmat.cc.

1439 {
1440  smpoly a;
1441  poly ha;
1442  int i, f;
1443  int e = crd;
1444 
1445  for (i=act; i; i--)
1446  {
1447  a = m_act[i];
1448  do
1449  {
1450  f = a->e;
1451  if (f < e)
1452  {
1453  ha = SM_MULT(a->m, m_res[e]->m, m_res[f]->m, _R);
1454  p_Delete(&a->m,_R);
1455  if (f) SM_DIV(ha, m_res[f]->m, _R);
1456  a->m = ha;
1457  }
1458  if (normalize) p_Normalize(a->m, _R);
1459  a = a->n;
1460  } while (a != NULL);
1461  }
1462 }
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:3621
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:850
#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 932 of file sparsmat.cc.

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

Definition at line 1602 of file sparsmat.cc.

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

Definition at line 1413 of file sparsmat.cc.

1414 {
1415  smpoly a = m_act[act];
1416  int e = crd;
1417  poly ha;
1418  int f;
1419 
1420  while (a != NULL)
1421  {
1422  f = a->e;
1423  if (f < e)
1424  {
1425  ha = SM_MULT(a->m, m_res[e]->m, m_res[f]->m,_R);
1426  p_Delete(&a->m,_R);
1427  if (f) SM_DIV(ha, m_res[f]->m,_R);
1428  a->m = ha;
1429  if (normalize) p_Normalize(a->m,_R);
1430  }
1431  a = a->n;
1432  }
1433 }
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:3621
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:850
#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 1507 of file sparsmat.cc.

1508 {
1509  int f = a->e;
1510  poly r, h;
1511 
1512  if (f < crd)
1513  {
1514  h = r = a->m;
1515  h = SM_MULT(h, m_res[crd]->m, m_res[f]->m, _R);
1516  if (f) SM_DIV(h, m_res[f]->m, _R);
1517  a->m = h;
1518  if (normalize) p_Normalize(a->m,_R);
1519  a->f = sm_PolyWeight(a,_R);
1520  return r;
1521  }
1522  else
1523  return NULL;
1524 }
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:3621
#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:2228
polyrec * poly
Definition: hilb.h:10
static Poly * h
Definition: janet.cc:978
void sparse_mat::smNewBareiss ( int  x,
int  y 
)

Definition at line 603 of file sparsmat.cc.

604 {
605  if ((x > 0) && (x < nrows))
606  {
607  tored -= x;
608  this->smToredElim();
609  }
610  if (y < 1) y = 1;
611  if (act <= y)
612  {
613  this->smCopToRes();
614  return;
615  }
616  normalize = this->smCheckNormalize();
617  if (normalize) this->smNormalize();
618  this->smPivot();
619  this->smSelectPR();
620  this->sm1Elim();
621  crd++;
622  this->smColToRow();
623  act--;
624  this->smRowToCol();
625  this->smZeroElim();
626  if (tored != nrows)
627  this->smToredElim();
628  if (act <= y)
629  {
630  this->smFinalMult();
631  this->smCopToRes();
632  return;
633  }
634  loop
635  {
636  if (normalize) this->smNormalize();
637  this->smNewPivot();
638  this->smSelectPR();
639  this->smMultCol();
640  this->smHElim();
641  crd++;
642  this->smColToRow();
643  act--;
644  this->smRowToCol();
645  this->smZeroElim();
646  if (tored != nrows)
647  this->smToredElim();
648  if (act <= y)
649  {
650  if (TEST_OPT_PROT) PrintS(".\n");
651  this->smFinalMult();
652  this->smCopToRes();
653  return;
654  }
655  }
656 }
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:1155
void smNormalize()
Definition: sparsmat.cc:1487
void smPivot()
Definition: sparsmat.cc:696
int smCheckNormalize()
Definition: sparsmat.cc:1467
int normalize
Definition: sparsmat.cc:139
void smSelectPR()
Definition: sparsmat.cc:1071
void smNewPivot()
Definition: sparsmat.cc:791
void PrintS(const char *s)
Definition: reporter.cc:294
void smHElim()
Definition: sparsmat.cc:932
void sm1Elim()
Definition: sparsmat.cc:853
void smColToRow()
Definition: sparsmat.cc:1135
Variable x
Definition: cfModGcd.cc:4023
void smMultCol()
Definition: sparsmat.cc:1413
void smCopToRes()
Definition: sparsmat.cc:1257
void smToredElim()
Definition: sparsmat.cc:1218
void smZeroElim()
Definition: sparsmat.cc:1188
void smFinalMult()
Definition: sparsmat.cc:1438
void sparse_mat::smNewPivot ( )
private

Definition at line 791 of file sparsmat.cc.

792 {
793  float wopt = 1.0e30, hp = piv->f;
794  float wc, wr, wp, w;
795  smpoly a;
796  int i, copt, ropt, f, e = crd;
797 
798  this->smNewWeights();
799  for (i=act; i; i--)
800  {
801  a = m_act[i];
802  loop
803  {
804  if (a->pos > tored)
805  break;
806  w = a->f;
807  f = a->e;
808  if (f < e)
809  {
810  w *= hp;
811  if (f) w /= m_res[f]->f;
812  }
813  wc = wcl[i]-w;
814  wr = wrw[a->pos]-w;
815  if ((wr<0.25) || (wc<0.25)) // row or column with only one point
816  {
817  if (w<wopt)
818  {
819  wopt = w;
820  copt = i;
821  ropt = a->pos;
822  }
823  }
824  else // elimination
825  {
826  wp = w*(wpoints-wcl[i]-wr);
827  wp += wr*wc;
828  if (wp < wopt)
829  {
830  wopt = wp;
831  copt = i;
832  ropt = a->pos;
833  }
834  }
835  a = a->n;
836  if (a == NULL)
837  break;
838  }
839  }
840  rpiv = ropt;
841  cpiv = copt;
842  if (cpiv != act)
843  {
844  a = m_act[act];
845  m_act[act] = m_act[cpiv];
846  m_act[cpiv] = a;
847  }
848 }
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:753
void sparse_mat::smNewWeights ( )
private

Definition at line 753 of file sparsmat.cc.

754 {
755  float wc, wp, w, hp = piv->f;
756  smpoly a;
757  int i, f, e = crd;
758 
759  wp = 0.0;
760  for (i=tored; i; i--) wrw[i] = 0.0; // ???
761  for (i=act; i; i--)
762  {
763  wc = 0.0;
764  a = m_act[i];
765  loop
766  {
767  if (a->pos > tored)
768  break;
769  w = a->f;
770  f = a->e;
771  if (f < e)
772  {
773  w *= hp;
774  if (f) w /= m_res[f]->f;
775  }
776  wc += w;
777  wrw[a->pos] += w;
778  a = a->n;
779  if (a == NULL)
780  break;
781  }
782  wp += wc;
783  wcl[i] = wc;
784  }
785  wpoints = wp;
786 }
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 1487 of file sparsmat.cc.

1488 {
1489  smpoly a;
1490  int i;
1491  int e = crd;
1492 
1493  for (i=act; i; i--)
1494  {
1495  a = m_act[i];
1496  do
1497  {
1498  if (e == a->e) p_Normalize(a->m,_R);
1499  a = a->n;
1500  } while (a != NULL);
1501  }
1502 }
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:3621
#define NULL
Definition: omList.c:10
void sparse_mat::smPivDel ( )
private

Definition at line 1560 of file sparsmat.cc.

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

Definition at line 696 of file sparsmat.cc.

697 {
698  float wopt = 1.0e30;
699  float wc, wr, wp, w;
700  smpoly a;
701  int i, copt, ropt;
702 
703  this->smWeights();
704  for (i=act; i; i--)
705  {
706  a = m_act[i];
707  loop
708  {
709  if (a->pos > tored)
710  break;
711  w = a->f;
712  wc = wcl[i]-w;
713  wr = wrw[a->pos]-w;
714  if ((wr<0.25) || (wc<0.25)) // row or column with only one point
715  {
716  if (w<wopt)
717  {
718  wopt = w;
719  copt = i;
720  ropt = a->pos;
721  }
722  }
723  else // elimination
724  {
725  wp = w*(wpoints-wcl[i]-wr);
726  wp += wr*wc;
727  if (wp < wopt)
728  {
729  wopt = wp;
730  copt = i;
731  ropt = a->pos;
732  }
733  }
734  a = a->n;
735  if (a == NULL)
736  break;
737  }
738  }
739  rpiv = ropt;
740  cpiv = copt;
741  if (cpiv != act)
742  {
743  a = m_act[act];
744  m_act[act] = m_act[cpiv];
745  m_act[cpiv] = a;
746  }
747 }
const poly a
Definition: syzextra.cc:212
void smWeights()
Definition: sparsmat.cc:664
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--) res->m[i-1] = sm_Smpoly2Poly(m_res[i],_R);
511  res->rank = id_RankFreeModule(res,_R);
512  return res;
513 }
static poly sm_Smpoly2Poly(smpoly, const ring)
Definition: sparsmat.cc:2187
smpoly * m_res
Definition: sparsmat.cc:144
poly res
Definition: myNF.cc:322
long id_RankFreeModule(ideal s, ring lmRing, ring tailRing)
return the maximal component number found in any polynomial in s
int i
Definition: cfEzgcd.cc:123
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
void sparse_mat::smRowToCol ( )
private

Definition at line 1155 of file sparsmat.cc.

1156 {
1157  smpoly r = m_row[rpiv];
1158  smpoly a, ap, h;
1159 
1160  m_row[rpiv] = NULL;
1161  perm[crd] = rpiv;
1162  piv->pos = crd;
1163  m_res[crd] = piv;
1164  while (r != NULL)
1165  {
1166  ap = m_res[r->pos];
1167  loop
1168  {
1169  a = ap->n;
1170  if (a == NULL)
1171  {
1172  ap->n = h = r;
1173  r = r->n;
1174  h->n = a;
1175  h->pos = crd;
1176  break;
1177  }
1178  ap = a;
1179  }
1180  }
1181 }
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 1071 of file sparsmat.cc.

1072 {
1073  smpoly b = dumm;
1074  smpoly a, ap;
1075  int i;
1076 
1077  if (TEST_OPT_PROT)
1078  {
1079  if ((crd+1)%10)
1080  PrintS(".");
1081  else
1082  PrintS(".\n");
1083  }
1084  a = m_act[act];
1085  if (a->pos < rpiv)
1086  {
1087  do
1088  {
1089  ap = a;
1090  a = a->n;
1091  } while (a->pos < rpiv);
1092  ap->n = a->n;
1093  }
1094  else
1095  m_act[act] = a->n;
1096  piv = a;
1097  a->n = NULL;
1098  for (i=1; i<act; i++)
1099  {
1100  a = m_act[i];
1101  if (a->pos < rpiv)
1102  {
1103  loop
1104  {
1105  ap = a;
1106  a = a->n;
1107  if ((a == NULL) || (a->pos > rpiv))
1108  break;
1109  if (a->pos == rpiv)
1110  {
1111  ap->n = a->n;
1112  a->m = p_Neg(a->m,_R);
1113  b = b->n = a;
1114  b->pos = i;
1115  break;
1116  }
1117  }
1118  }
1119  else if (a->pos == rpiv)
1120  {
1121  m_act[i] = a->n;
1122  a->m = p_Neg(a->m,_R);
1123  b = b->n = a;
1124  b->pos = i;
1125  }
1126  }
1127  b->n = NULL;
1128  red = dumm->n;
1129 }
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:1018
const poly b
Definition: syzextra.cc:213
void sparse_mat::smSign ( )
private

Definition at line 1574 of file sparsmat.cc.

1575 {
1576  int j,i;
1577  if (act > 2)
1578  {
1579  if (cpiv!=act) sign=-sign;
1580  if ((act%2)==0) sign=-sign;
1581  i=1;
1582  j=perm[1];
1583  while(j<rpiv)
1584  {
1585  sign=-sign;
1586  i++;
1587  j=perm[i];
1588  }
1589  while(perm[i]!=0)
1590  {
1591  perm[i]=perm[i+1];
1592  i++;
1593  }
1594  }
1595  else
1596  {
1597  if (cpiv!=1) sign=-sign;
1598  if (rpiv!=perm[1]) sign=-sign;
1599  }
1600 }
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 518 of file sparsmat.cc.

519 {
520  int i;
521 
522  for (i=v->rows()-1; i>=0; i--)
523  (*v)[i] = perm[i+1];
524 }
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 1218 of file sparsmat.cc.

1219 {
1220  int i = 0;
1221  int j;
1222 
1223  loop
1224  {
1225  i++;
1226  if (i > act) return;
1227  if (m_act[i]->pos > tored)
1228  {
1229  m_res[inred] = m_act[i];
1230  inred--;
1231  break;
1232  }
1233  }
1234  j = i;
1235  loop
1236  {
1237  j++;
1238  if (j > act) break;
1239  if (m_act[j]->pos > tored)
1240  {
1241  m_res[inred] = m_act[j];
1242  inred--;
1243  }
1244  else
1245  {
1246  m_act[i] = m_act[j];
1247  i++;
1248  }
1249  }
1250  act -= (j-i);
1251  sign = 0;
1252 }
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 664 of file sparsmat.cc.

665 {
666  float wc, wp, w;
667  smpoly a;
668  int i;
669 
670  wp = 0.0;
671  for (i=tored; i; i--) wrw[i] = 0.0; // ???
672  for (i=act; i; i--)
673  {
674  wc = 0.0;
675  a = m_act[i];
676  loop
677  {
678  if (a->pos > tored)
679  break;
680  w = a->f = sm_PolyWeight(a,_R);
681  wc += w;
682  wrw[a->pos] += w;
683  a = a->n;
684  if (a == NULL)
685  break;
686  }
687  wp += wc;
688  wcl[i] = wc;
689  }
690  wpoints = wp;
691 }
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:2228
void sparse_mat::smZeroElim ( )
private

Definition at line 1188 of file sparsmat.cc.

1189 {
1190  int i = 0;
1191  int j;
1192 
1193  loop
1194  {
1195  i++;
1196  if (i > act) return;
1197  if (m_act[i] == NULL) break;
1198  }
1199  j = i;
1200  loop
1201  {
1202  j++;
1203  if (j > act) break;
1204  if (m_act[j] != NULL)
1205  {
1206  m_act[i] = m_act[j];
1207  i++;
1208  }
1209  }
1210  act -= (j-i);
1211  sign = 0;
1212 }
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: