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

Constructor & Destructor Documentation

◆ sparse_mat()

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

Definition at line 439 of file sparsmat.cc.

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

◆ ~sparse_mat()

sparse_mat::~sparse_mat ( )

Definition at line 481 of file sparsmat.cc.

482 {
483  int i;
484  if (m_act == NULL) return;
487  i = ncols+1;
488  omFreeSize((ADDRESS)m_res, sizeof(smpoly)*i);
489  omFreeSize((ADDRESS)m_act, sizeof(smpoly)*i);
490  omFreeSize((ADDRESS)wcl, sizeof(float)*i);
491  i = nrows+1;
492  omFreeSize((ADDRESS)wrw, sizeof(float)*i);
493  omFreeSize((ADDRESS)m_row, sizeof(smpoly)*i);
494  omFreeSize((ADDRESS)perm, sizeof(int)*(i+1));
495 }
smpoly * m_res
Definition: sparsmat.cc:139
smpoly dumm
Definition: sparsmat.cc:143
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
omBin smprec_bin
Definition: sparsmat.cc:75
void * ADDRESS
Definition: auxiliary.h:115
sm_prec * smpoly
Definition: sparsmat.cc:47
float * wrw
Definition: sparsmat.cc:137
int i
Definition: cfEzgcd.cc:123
int * perm
Definition: sparsmat.cc:135
smpoly * m_act
Definition: sparsmat.cc:138
smpoly * m_row
Definition: sparsmat.cc:140
float * wcl
Definition: sparsmat.cc:137
#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 852 of file sparsmat.cc.

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

◆ smActDel()

void sparse_mat::smActDel ( )
private

Definition at line 1528 of file sparsmat.cc.

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

◆ smCheckNormalize()

int sparse_mat::smCheckNormalize ( )
private

Definition at line 1466 of file sparsmat.cc.

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

◆ smColDel()

void sparse_mat::smColDel ( )
private

Definition at line 1546 of file sparsmat.cc.

1547 {
1548  smpoly a = m_act[act];
1549 
1550  while (a != NULL)
1551  {
1552  sm_ElemDelete(&a,_R);
1553  }
1554 }
const poly a
Definition: syzextra.cc:212
sm_prec * smpoly
Definition: sparsmat.cc:47
smpoly * m_act
Definition: sparsmat.cc:138
#define NULL
Definition: omList.c:10
static void sm_ElemDelete(smpoly *, const ring)
Definition: sparsmat.cc:2129

◆ smColToRow()

void sparse_mat::smColToRow ( )
private

Definition at line 1134 of file sparsmat.cc.

1135 {
1136  smpoly c = m_act[act];
1137  smpoly h;
1138 
1139  while (c != NULL)
1140  {
1141  h = c;
1142  c = c->n;
1143  h->n = m_row[h->pos];
1144  m_row[h->pos] = h;
1145  h->pos = crd;
1146  }
1147 }
sm_prec * smpoly
Definition: sparsmat.cc:47
smpoly * m_act
Definition: sparsmat.cc:138
smpoly * m_row
Definition: sparsmat.cc:140
#define NULL
Definition: omList.c:10
static Poly * h
Definition: janet.cc:978

◆ smCopToRes()

void sparse_mat::smCopToRes ( )
private

Definition at line 1256 of file sparsmat.cc.

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

529 {
530  poly res = NULL;
531 
532  if (sign == 0)
533  {
534  this->smActDel();
535  return NULL;
536  }
537  if (act < 2)
538  {
539  if (act != 0) res = m_act[1]->m;
540  omFreeBin((void *)m_act[1], smprec_bin);
541  return res;
542  }
543  normalize = 0;
544  this->smInitPerm();
545  this->smPivot();
546  this->smSign();
547  this->smSelectPR();
548  this->sm1Elim();
549  crd++;
550  m_res[crd] = piv;
551  this->smColDel();
552  act--;
553  this->smZeroElim();
554  if (sign == 0)
555  {
556  this->smActDel();
557  return NULL;
558  }
559  if (act < 2)
560  {
561  this->smFinalMult();
562  this->smPivDel();
563  if (act != 0) res = m_act[1]->m;
564  omFreeBin((void *)m_act[1], smprec_bin);
565  return res;
566  }
567  loop
568  {
569  this->smNewPivot();
570  this->smSign();
571  this->smSelectPR();
572  this->smMultCol();
573  this->smHElim();
574  crd++;
575  m_res[crd] = piv;
576  this->smColDel();
577  act--;
578  this->smZeroElim();
579  if (sign == 0)
580  {
581  this->smPivDel();
582  this->smActDel();
583  return NULL;
584  }
585  if (act < 2)
586  {
587  if (TEST_OPT_PROT) PrintS(".\n");
588  this->smFinalMult();
589  this->smPivDel();
590  if (act != 0) res = m_act[1]->m;
591  omFreeBin((void *)m_act[1], smprec_bin);
592  return res;
593  }
594  }
595 }
smpoly * m_res
Definition: sparsmat.cc:139
#define TEST_OPT_PROT
Definition: options.h:98
loop
Definition: myNF.cc:98
void smPivot()
Definition: sparsmat.cc:695
omBin smprec_bin
Definition: sparsmat.cc:75
void smActDel()
Definition: sparsmat.cc:1528
int normalize
Definition: sparsmat.cc:134
poly res
Definition: myNF.cc:322
void smSelectPR()
Definition: sparsmat.cc:1070
void smNewPivot()
Definition: sparsmat.cc:790
void smColDel()
Definition: sparsmat.cc:1546
smpoly piv
Definition: sparsmat.cc:142
void PrintS(const char *s)
Definition: reporter.cc:284
void smPivDel()
Definition: sparsmat.cc:1559
smpoly * m_act
Definition: sparsmat.cc:138
void smHElim()
Definition: sparsmat.cc:931
void sm1Elim()
Definition: sparsmat.cc:852
#define NULL
Definition: omList.c:10
void smInitPerm()
Definition: sparsmat.cc:1601
void smSign()
Definition: sparsmat.cc:1573
void smMultCol()
Definition: sparsmat.cc:1412
void smZeroElim()
Definition: sparsmat.cc:1187
polyrec * poly
Definition: hilb.h:10
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
void smFinalMult()
Definition: sparsmat.cc:1437

◆ smFinalMult()

void sparse_mat::smFinalMult ( )
private

Definition at line 1437 of file sparsmat.cc.

1438 {
1439  smpoly a;
1440  poly ha;
1441  int i, f;
1442  int e = crd;
1443 
1444  for (i=act; i; i--)
1445  {
1446  a = m_act[i];
1447  do
1448  {
1449  f = a->e;
1450  if (f < e)
1451  {
1452  ha = SM_MULT(a->m, m_res[e]->m, m_res[f]->m, _R);
1453  p_Delete(&a->m,_R);
1454  if (f) SM_DIV(ha, m_res[f]->m, _R);
1455  a->m = ha;
1456  }
1457  if (normalize) p_Normalize(a->m, _R);
1458  a = a->n;
1459  } while (a != NULL);
1460  }
1461 }
const poly a
Definition: syzextra.cc:212
smpoly * m_res
Definition: sparsmat.cc:139
sm_prec * smpoly
Definition: sparsmat.cc:47
int normalize
Definition: sparsmat.cc:134
int m
Definition: cfEzgcd.cc:119
FILE * f
Definition: checklibs.c:9
int i
Definition: cfEzgcd.cc:123
smpoly * m_act
Definition: sparsmat.cc:138
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3680
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 173 of file sparsmat.cc.

173 { return m_act; }
smpoly * m_act
Definition: sparsmat.cc:138

◆ smGetRed()

int sparse_mat::smGetRed ( )
inline

Definition at line 174 of file sparsmat.cc.

174 { return tored; }

◆ smGetSign()

int sparse_mat::smGetSign ( )
inline

Definition at line 172 of file sparsmat.cc.

172 { return sign; }

◆ smHElim()

void sparse_mat::smHElim ( )
private

Definition at line 931 of file sparsmat.cc.

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

◆ smInitPerm()

void sparse_mat::smInitPerm ( )
private

Definition at line 1601 of file sparsmat.cc.

1602 {
1603  int i;
1604  for (i=act;i;i--) perm[i]=i;
1605 }
int i
Definition: cfEzgcd.cc:123
int * perm
Definition: sparsmat.cc:135

◆ smMultCol()

void sparse_mat::smMultCol ( )
private

Definition at line 1412 of file sparsmat.cc.

1413 {
1414  smpoly a = m_act[act];
1415  int e = crd;
1416  poly ha;
1417  int f;
1418 
1419  while (a != NULL)
1420  {
1421  f = a->e;
1422  if (f < e)
1423  {
1424  ha = SM_MULT(a->m, m_res[e]->m, m_res[f]->m,_R);
1425  p_Delete(&a->m,_R);
1426  if (f) SM_DIV(ha, m_res[f]->m,_R);
1427  a->m = ha;
1428  if (normalize) p_Normalize(a->m,_R);
1429  }
1430  a = a->n;
1431  }
1432 }
const poly a
Definition: syzextra.cc:212
smpoly * m_res
Definition: sparsmat.cc:139
sm_prec * smpoly
Definition: sparsmat.cc:47
int normalize
Definition: sparsmat.cc:134
int m
Definition: cfEzgcd.cc:119
FILE * f
Definition: checklibs.c:9
smpoly * m_act
Definition: sparsmat.cc:138
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3680
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 1506 of file sparsmat.cc.

1507 {
1508  int f = a->e;
1509  poly r, h;
1510 
1511  if (f < crd)
1512  {
1513  h = r = a->m;
1514  h = SM_MULT(h, m_res[crd]->m, m_res[f]->m, _R);
1515  if (f) SM_DIV(h, m_res[f]->m, _R);
1516  a->m = h;
1517  if (normalize) p_Normalize(a->m,_R);
1518  a->f = sm_PolyWeight(a,_R);
1519  return r;
1520  }
1521  else
1522  return NULL;
1523 }
const poly a
Definition: syzextra.cc:212
smpoly * m_res
Definition: sparsmat.cc:139
int normalize
Definition: sparsmat.cc:134
const ring r
Definition: syzextra.cc:208
int m
Definition: cfEzgcd.cc:119
FILE * f
Definition: checklibs.c:9
void p_Normalize(poly p, const ring r)
Definition: p_polys.cc:3680
#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

◆ smNewBareiss()

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

Definition at line 602 of file sparsmat.cc.

603 {
604  if ((x > 0) && (x < nrows))
605  {
606  tored -= x;
607  this->smToredElim();
608  }
609  if (y < 1) y = 1;
610  if (act <= y)
611  {
612  this->smCopToRes();
613  return;
614  }
615  normalize = this->smCheckNormalize();
616  if (normalize) this->smNormalize();
617  this->smPivot();
618  this->smSelectPR();
619  this->sm1Elim();
620  crd++;
621  this->smColToRow();
622  act--;
623  this->smRowToCol();
624  this->smZeroElim();
625  if (tored != nrows)
626  this->smToredElim();
627  if (act <= y)
628  {
629  this->smFinalMult();
630  this->smCopToRes();
631  return;
632  }
633  loop
634  {
635  if (normalize) this->smNormalize();
636  this->smNewPivot();
637  this->smSelectPR();
638  this->smMultCol();
639  this->smHElim();
640  crd++;
641  this->smColToRow();
642  act--;
643  this->smRowToCol();
644  this->smZeroElim();
645  if (tored != nrows)
646  this->smToredElim();
647  if (act <= y)
648  {
649  if (TEST_OPT_PROT) PrintS(".\n");
650  this->smFinalMult();
651  this->smCopToRes();
652  return;
653  }
654  }
655 }
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:1154
void smNormalize()
Definition: sparsmat.cc:1486
void smPivot()
Definition: sparsmat.cc:695
int smCheckNormalize()
Definition: sparsmat.cc:1466
int normalize
Definition: sparsmat.cc:134
void smSelectPR()
Definition: sparsmat.cc:1070
void smNewPivot()
Definition: sparsmat.cc:790
void PrintS(const char *s)
Definition: reporter.cc:284
void smHElim()
Definition: sparsmat.cc:931
void sm1Elim()
Definition: sparsmat.cc:852
void smColToRow()
Definition: sparsmat.cc:1134
Variable x
Definition: cfModGcd.cc:4023
void smMultCol()
Definition: sparsmat.cc:1412
void smCopToRes()
Definition: sparsmat.cc:1256
void smToredElim()
Definition: sparsmat.cc:1217
void smZeroElim()
Definition: sparsmat.cc:1187
void smFinalMult()
Definition: sparsmat.cc:1437

◆ smNewPivot()

void sparse_mat::smNewPivot ( )
private

Definition at line 790 of file sparsmat.cc.

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

◆ smNewWeights()

void sparse_mat::smNewWeights ( )
private

Definition at line 752 of file sparsmat.cc.

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

◆ smNormalize()

void sparse_mat::smNormalize ( )
private

Definition at line 1486 of file sparsmat.cc.

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

◆ smPivDel()

void sparse_mat::smPivDel ( )
private

Definition at line 1559 of file sparsmat.cc.

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

◆ smPivot()

void sparse_mat::smPivot ( )
private

Definition at line 695 of file sparsmat.cc.

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

◆ smRes2Mod()

ideal sparse_mat::smRes2Mod ( )

Definition at line 501 of file sparsmat.cc.

502 {
503  ideal res = idInit(crd, crd);
504  int i;
505 
506  for (i=crd; i; i--)
507  {
508  res->m[i-1] = sm_Smpoly2Poly(m_res[i],_R);
509  res->rank=si_max(res->rank, p_MaxComp(res->m[i-1],_R));
510  }
511  return res;
512 }
static poly sm_Smpoly2Poly(smpoly, const ring)
Definition: sparsmat.cc:2187
smpoly * m_res
Definition: sparsmat.cc:139
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 1154 of file sparsmat.cc.

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

◆ smSelectPR()

void sparse_mat::smSelectPR ( )
private

Definition at line 1070 of file sparsmat.cc.

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

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

◆ smSparseHomog()

void sparse_mat::smSparseHomog ( )
private

◆ smToIntvec()

void sparse_mat::smToIntvec ( intvec v)

Definition at line 517 of file sparsmat.cc.

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

◆ smToredElim()

void sparse_mat::smToredElim ( )
private

Definition at line 1217 of file sparsmat.cc.

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

◆ smWeights()

void sparse_mat::smWeights ( )
private

Definition at line 663 of file sparsmat.cc.

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

◆ smZeroElim()

void sparse_mat::smZeroElim ( )
private

Definition at line 1187 of file sparsmat.cc.

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

Field Documentation

◆ _R

ring sparse_mat::_R
private

Definition at line 144 of file sparsmat.cc.

◆ act

int sparse_mat::act
private

Definition at line 129 of file sparsmat.cc.

◆ cpiv

int sparse_mat::cpiv
private

Definition at line 133 of file sparsmat.cc.

◆ crd

int sparse_mat::crd
private

Definition at line 130 of file sparsmat.cc.

◆ dumm

smpoly sparse_mat::dumm
private

Definition at line 143 of file sparsmat.cc.

◆ inred

int sparse_mat::inred
private

Definition at line 132 of file sparsmat.cc.

◆ m_act

smpoly* sparse_mat::m_act
private

Definition at line 138 of file sparsmat.cc.

◆ m_res

smpoly* sparse_mat::m_res
private

Definition at line 139 of file sparsmat.cc.

◆ m_row

smpoly* sparse_mat::m_row
private

Definition at line 140 of file sparsmat.cc.

◆ ncols

int sparse_mat::ncols
private

Definition at line 127 of file sparsmat.cc.

◆ normalize

int sparse_mat::normalize
private

Definition at line 134 of file sparsmat.cc.

◆ nrows

int sparse_mat::nrows
private

Definition at line 127 of file sparsmat.cc.

◆ oldpiv

smpoly sparse_mat::oldpiv
private

Definition at line 142 of file sparsmat.cc.

◆ perm

int* sparse_mat::perm
private

Definition at line 135 of file sparsmat.cc.

◆ piv

smpoly sparse_mat::piv
private

Definition at line 142 of file sparsmat.cc.

◆ red

smpoly sparse_mat::red
private

Definition at line 141 of file sparsmat.cc.

◆ rpiv

int sparse_mat::rpiv
private

Definition at line 133 of file sparsmat.cc.

◆ sign

int sparse_mat::sign
private

Definition at line 128 of file sparsmat.cc.

◆ tored

int sparse_mat::tored
private

Definition at line 131 of file sparsmat.cc.

◆ wcl

float * sparse_mat::wcl
private

Definition at line 137 of file sparsmat.cc.

◆ wpoints

float sparse_mat::wpoints
private

Definition at line 136 of file sparsmat.cc.

◆ wrw

float* sparse_mat::wrw
private

Definition at line 137 of file sparsmat.cc.


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