Public Member Functions | Protected Member Functions | Private Member Functions | Private Attributes
PolyMinorProcessor Class Reference

Class PolyMinorProcessor is derived from class MinorProcessor. More...

#include <MinorProcessor.h>

Public Member Functions

 PolyMinorProcessor ()
 A constructor for creating an instance. More...
 
 ~PolyMinorProcessor ()
 A destructor for deleting an instance. More...
 
void defineMatrix (const int numberOfRows, const int numberOfColumns, const poly *polyMatrix)
 A method for defining a matrix with polynomial entries. More...
 
PolyMinorValue getMinor (const int dimension, const int *rowIndices, const int *columnIndices, const char *algorithm, const ideal &iSB)
 A method for computing the value of a minor, without using a cache. More...
 
PolyMinorValue getMinor (const int dimension, const int *rowIndices, const int *columnIndices, Cache< MinorKey, PolyMinorValue > &c, const ideal &iSB)
 A method for computing the value of a minor, using a cache. More...
 
PolyMinorValue getNextMinor (const char *algorithm, const ideal &iSB)
 A method for obtaining the next minor when iterating through all minors of a given size within a pre-defined sub-matrix of an underlying matrix. More...
 
PolyMinorValue getNextMinor (Cache< MinorKey, PolyMinorValue > &c, const ideal &iSB)
 A method for obtaining the next minor when iterating through all minors of a given size within a pre-defined sub-matrix of an underlying matrix. More...
 
std::string toString () const
 A method for providing a printable version of the represented MinorProcessor. More...
 
- Public Member Functions inherited from MinorProcessor
 MinorProcessor ()
 The default constructor. More...
 
virtual ~MinorProcessor ()
 A destructor for deleting an instance. More...
 
void defineSubMatrix (const int numberOfRows, const int *rowIndices, const int numberOfColumns, const int *columnIndices)
 A method for defining a sub-matrix within a pre-defined matrix. More...
 
void setMinorSize (const int minorSize)
 Sets the size of the minor(s) of interest. More...
 
bool hasNextMinor ()
 A method for checking whether there is a next choice of rows and columns when iterating through all minors of a given size within a pre-defined sub-matrix of an underlying matrix. More...
 
void getCurrentRowIndices (int *const target) const
 A method for obtaining the current set of rows corresponding to the current minor when iterating through all minors of a given size within a pre-defined sub-matrix of an underlying matrix. More...
 
void getCurrentColumnIndices (int *const target) const
 A method for obtaining the current set of columns corresponding to the current minor when iterating through all minors of a given size within a pre-defined sub-matrix of an underlying matrix. More...
 
void print () const
 A method for printing a string representation of the given MinorProcessor to std::cout. More...
 

Protected Member Functions

bool isEntryZero (const int absoluteRowIndex, const int absoluteColumnIndex) const
 A method for testing whether a matrix entry is zero. More...
 
- Protected Member Functions inherited from MinorProcessor
bool setNextKeys (const int k)
 A method for iterating through all possible subsets of k rows and k columns inside a pre-defined submatrix of a pre-defined matrix. More...
 
int getBestLine (const int k, const MinorKey &mk) const
 A method for identifying the row or column with the most zeros. More...
 

Private Member Functions

poly getEntry (const int rowIndex, const int columnIndex) const
 A method for retrieving the matrix entry. More...
 
PolyMinorValue getMinorPrivateLaplace (const int k, const MinorKey &mk, const bool multipleMinors, Cache< MinorKey, PolyMinorValue > &c, const ideal &iSB)
 A method for computing the value of a minor, using a cache. More...
 
PolyMinorValue getMinorPrivateLaplace (const int k, const MinorKey &mk, const ideal &iSB)
 A method for computing the value of a minor, without using a cache. More...
 
PolyMinorValue getMinorPrivateBareiss (const int k, const MinorKey &mk, const ideal &iSB)
 A method for computing the value of a minor, without using a cache. More...
 

Private Attributes

poly_polyMatrix
 private store for polynomial matrix entries More...
 

Additional Inherited Members

- Static Protected Member Functions inherited from MinorProcessor
static int NumberOfRetrievals (const int rows, const int columns, const int containerMinorSize, const int minorSize, const bool multipleMinors)
 A static method for computing the maximum number of retrievals of a minor. More...
 
static int IOverJ (const int i, const int j)
 A static method for computing the binomial coefficient i over j. More...
 
static int Faculty (const int i)
 A static method for computing the factorial of i. More...
 
- Protected Attributes inherited from MinorProcessor
MinorKey _container
 private store for the rows and columns of the container minor within the underlying matrix; _container will be used to fix a submatrix (e.g. More...
 
int _containerRows
 private store for the number of rows in the container minor; This is set by MinorProcessor::defineSubMatrix (const int, const int*, const int, const int*). More...
 
int _containerColumns
 private store for the number of columns in the container minor; This is set by MinorProcessor::defineSubMatrix (const int, const int*, const int, const int*). More...
 
MinorKey _minor
 private store for the rows and columns of the minor of interest; Usually, this minor will encode subsets of the rows and columns in _container. More...
 
int _minorSize
 private store for the dimension of the minor(s) of interest More...
 
int _rows
 private store for the number of rows in the underlying matrix More...
 
int _columns
 private store for the number of columns in the underlying matrix More...
 

Detailed Description

Class PolyMinorProcessor is derived from class MinorProcessor.

This class implements the special case of polynomial matrices.

Author
Frank Seelisch, http://www.mathematik.uni-kl.de/~seelisch

Definition at line 563 of file MinorProcessor.h.

Constructor & Destructor Documentation

PolyMinorProcessor::PolyMinorProcessor ( )

A constructor for creating an instance.

Definition at line 809 of file MinorProcessor.cc.

810 {
811  _polyMatrix = 0;
812 }
poly * _polyMatrix
private store for polynomial matrix entries
PolyMinorProcessor::~PolyMinorProcessor ( )

A destructor for deleting an instance.

Definition at line 859 of file MinorProcessor.cc.

860 {
861  /* free memory of _polyMatrix */
862  int n = _rows * _columns;
863  for (int i = 0; i < n; i++)
865  delete [] _polyMatrix; _polyMatrix = 0;
866 }
int _rows
private store for the number of rows in the underlying matrix
int _columns
private store for the number of columns in the underlying matrix
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
int i
Definition: cfEzgcd.cc:123
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:849
poly * _polyMatrix
private store for polynomial matrix entries

Member Function Documentation

void PolyMinorProcessor::defineMatrix ( const int  numberOfRows,
const int  numberOfColumns,
const poly polyMatrix 
)

A method for defining a matrix with polynomial entries.

Parameters
numberOfRowsthe number of rows
numberOfColumnsthe number of columns
polyMatrixthe matrix entries in a linear array, i.e., from left to right and top to bottom
See also
MinorValue::defineSubMatrix (const int, const int*, const int, const int*)

Definition at line 868 of file MinorProcessor.cc.

871 {
872  /* free memory of _polyMatrix */
873  int n = _rows * _columns;
874  for (int i = 0; i < n; i++)
876  delete [] _polyMatrix; _polyMatrix = 0;
877 
878  _rows = numberOfRows;
879  _columns = numberOfColumns;
880  n = _rows * _columns;
881 
882  /* allocate memory for new entries in _polyMatrix */
883  _polyMatrix = new poly[n];
884 
885  /* copying values from one-dimensional method
886  parameter "polyMatrix" */
887  for (int i = 0; i < n; i++)
888  _polyMatrix[i] = pCopy(polyMatrix[i]);
889 }
int _rows
private store for the number of rows in the underlying matrix
int _columns
private store for the number of columns in the underlying matrix
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
int i
Definition: cfEzgcd.cc:123
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:849
poly * _polyMatrix
private store for polynomial matrix entries
polyrec * poly
Definition: hilb.h:10
#define pCopy(p)
return a copy of the poly
Definition: polys.h:156
poly PolyMinorProcessor::getEntry ( const int  rowIndex,
const int  columnIndex 
) const
private

A method for retrieving the matrix entry.

Parameters
rowIndexthe absolute (zero-based) row index
columnIndexthe absolute (zero-based) column index
Returns
the specified matrix entry

Definition at line 814 of file MinorProcessor.cc.

816 {
817  return _polyMatrix[rowIndex * _columns + columnIndex];
818 }
int _columns
private store for the number of columns in the underlying matrix
poly * _polyMatrix
private store for polynomial matrix entries
PolyMinorValue PolyMinorProcessor::getMinor ( const int  dimension,
const int *  rowIndices,
const int *  columnIndices,
const char *  algorithm,
const ideal &  iSB 
)

A method for computing the value of a minor, without using a cache.


The sub-matrix is determined by rowIndices and columnIndices. Computation works either by Laplace's algorithm or by Bareiss's algorithm.
If an ideal is given, it is assumed to be a standard basis. In this case, all results will be reduced w.r.t. to this basis.

Parameters
dimensionthe size of the minor to be computed
rowIndices0-based indices of the rows of the minor
columnIndices0-based indices of the column of the minor
algorithmeither "Laplace" or "Bareiss"
iSBNULL or a standard basis
Returns
an instance of MinorValue representing the value of the corresponding minor
See also
MinorProcessor::getMinor (const int dimension, const int* rowIndices, const int* columnIndices, Cache<MinorKey, PolyMinorValue>& c, const ideal& iSB)

Definition at line 904 of file MinorProcessor.cc.

909 {
910  defineSubMatrix(dimension, rowIndices, dimension, columnIndices);
912  /* call a helper method which computes the minor (without using a cache): */
913  if (strcmp(algorithm, "Laplace") == 0)
915  else if (strcmp(algorithm, "Bareiss") == 0)
917  else assume(false);
918 
919  /* The following code is never reached and just there to make the
920  compiler happy: */
921  return PolyMinorValue();
922 }
PolyMinorValue getMinorPrivateBareiss(const int k, const MinorKey &mk, const ideal &iSB)
A method for computing the value of a minor, without using a cache.
int _minorSize
private store for the dimension of the minor(s) of interest
#define assume(x)
Definition: mod2.h:405
Class PolyMinorValue is derived from MinorValue and can be used for representing values in a cache fo...
Definition: Minor.h:799
MinorKey _container
private store for the rows and columns of the container minor within the underlying matrix; _containe...
BOOLEAN dimension(leftv res, leftv args)
Definition: bbcone.cc:701
void defineSubMatrix(const int numberOfRows, const int *rowIndices, const int numberOfColumns, const int *columnIndices)
A method for defining a sub-matrix within a pre-defined matrix.
PolyMinorValue getMinorPrivateLaplace(const int k, const MinorKey &mk, const bool multipleMinors, Cache< MinorKey, PolyMinorValue > &c, const ideal &iSB)
A method for computing the value of a minor, using a cache.
PolyMinorValue PolyMinorProcessor::getMinor ( const int  dimension,
const int *  rowIndices,
const int *  columnIndices,
Cache< MinorKey, PolyMinorValue > &  c,
const ideal &  iSB 
)

A method for computing the value of a minor, using a cache.


The sub-matrix is determined by rowIndices and columnIndices. Computation works recursively using Laplace's Theorem. We always develop along the row or column with most zeros; see MinorProcessor::getBestLine (const int, const int, const int). If an ideal is given, it is assumed to be a standard basis. In this case, all results will be reduced w.r.t. to this basis.

Parameters
dimensionthe size of the minor to be computed
rowIndices0-based indices of the rows of the minor
columnIndices0-based indices of the column of the minor
ca cache to be used for caching reusable sub-minors
iSBNULL or a standard basis
Returns
an instance of MinorValue representing the value of the corresponding minor
See also
MinorProcessor::(const int dimension, const int* rowIndices, const int* columnIndices, const char* algorithm, const ideal& iSB)

Definition at line 891 of file MinorProcessor.cc.

896 {
897  defineSubMatrix(dimension, rowIndices, dimension, columnIndices);
899  /* call a helper method which recursively computes the minor using the cache
900  c: */
901  return getMinorPrivateLaplace(dimension, _container, false, c, iSB);
902 }
int _minorSize
private store for the dimension of the minor(s) of interest
MinorKey _container
private store for the rows and columns of the container minor within the underlying matrix; _containe...
BOOLEAN dimension(leftv res, leftv args)
Definition: bbcone.cc:701
void defineSubMatrix(const int numberOfRows, const int *rowIndices, const int numberOfColumns, const int *columnIndices)
A method for defining a sub-matrix within a pre-defined matrix.
PolyMinorValue getMinorPrivateLaplace(const int k, const MinorKey &mk, const bool multipleMinors, Cache< MinorKey, PolyMinorValue > &c, const ideal &iSB)
A method for computing the value of a minor, using a cache.
PolyMinorValue PolyMinorProcessor::getMinorPrivateBareiss ( const int  k,
const MinorKey mk,
const ideal &  iSB 
)
private

A method for computing the value of a minor, without using a cache.


The sub-matrix is specified by mk. Computation works using Bareiss's algorithm. If an ideal is given, it is assumed to be a standard basis. In this case, all results will be reduced w.r.t. to this basis.

Parameters
kthe number of rows and columns in the minor to be comuted
mkthe representation of rows and columns of the minor to be comuted
iSBNULL or a standard basis
Returns
an instance of MinorValue representing the value of the corresponding minor
See also
MinorProcessor::getMinorPrivateLaplace (const int k, const MinorKey& mk, const ideal& iSB)

Definition at line 1389 of file MinorProcessor.cc.

1392 {
1393  assume(k > 0); /* k is the minor's dimension; the minor must be at least
1394  1x1 */
1395  int *theRows=new int[k]; mk.getAbsoluteRowIndices(theRows);
1396  int *theColumns=new int[k]; mk.getAbsoluteColumnIndices(theColumns);
1397  if (k == 1)
1398  {
1399  PolyMinorValue tmp=PolyMinorValue(getEntry(theRows[0], theColumns[0]),
1400  0, 0, 0, 0, -1, -1);
1401  delete[] theColumns;
1402  delete[] theRows;
1403  return tmp;
1404  }
1405  else /* k > 0 */
1406  {
1407  /* the matrix to perform Bareiss with */
1408  poly* tempMatrix = (poly*)omAlloc(k * k * sizeof(poly));
1409  /* copy correct set of entries from _polyMatrix to tempMatrix */
1410  int i = 0;
1411  for (int r = 0; r < k; r++)
1412  for (int c = 0; c < k; c++)
1413  tempMatrix[i++] = pCopy(getEntry(theRows[r], theColumns[c]));
1414 
1415  /* Bareiss algorithm operating on tempMatrix which is at least 2x2 */
1416  int sign = 1; /* This will store the correct sign resulting from
1417  permuting the rows of tempMatrix. */
1418  int *rowPermutation=new int[k]; /* This is for storing the permutation of rows
1419  resulting from searching for a non-zero pivot
1420  element. */
1421  for (int i = 0; i < k; i++) rowPermutation[i] = i;
1422  poly divisor = NULL;
1423  int divisorLength = 0;
1424  number divisorLC;
1425  for (int r = 0; r <= k - 2; r++)
1426  {
1427  /* look for a non-zero entry in column r, rows = r .. (k - 1)
1428  s.t. the polynomial has least complexity: */
1429  int minComplexity = -1; int complexity = 0; int bestRow = -1;
1430  poly pp = NULL;
1431  for (int i = r; i < k; i++)
1432  {
1433  pp = tempMatrix[rowPermutation[i] * k + r];
1434  if (pp != NULL)
1435  {
1436  if (minComplexity == -1)
1437  {
1438  minComplexity = pSize(pp);
1439  bestRow = i;
1440  }
1441  else
1442  {
1443  complexity = 0;
1444  while ((pp != NULL) && (complexity < minComplexity))
1445  {
1446  complexity += nSize(pGetCoeff(pp)); pp = pNext(pp);
1447  }
1448  if (complexity < minComplexity)
1449  {
1450  minComplexity = complexity;
1451  bestRow = i;
1452  }
1453  }
1454  if (minComplexity <= 1) break; /* terminate the search */
1455  }
1456  }
1457  if (bestRow == -1)
1458  {
1459  /* There is no non-zero entry; hence the minor is zero. */
1460  for (int i = 0; i < k * k; i++) pDelete(&tempMatrix[i]);
1461  return PolyMinorValue(NULL, 0, 0, 0, 0, -1, -1);
1462  }
1463  pNormalize(tempMatrix[rowPermutation[bestRow] * k + r]);
1464  if (bestRow != r)
1465  {
1466  /* We swap the rows with indices r and i: */
1467  int j = rowPermutation[bestRow];
1468  rowPermutation[bestRow] = rowPermutation[r];
1469  rowPermutation[r] = j;
1470  /* Now we know that tempMatrix[rowPermutation[r] * k + r] is not zero.
1471  But carefull; we have to negate the sign, as there is always an odd
1472  number of row transpositions to swap two given rows of a matrix. */
1473  sign = -sign;
1474  }
1475 #if (defined COUNT_AND_PRINT_OPERATIONS) && (COUNT_AND_PRINT_OPERATIONS > 2)
1476  poly w = NULL; int wl = 0;
1477  printf("matrix after %d steps:\n", r);
1478  for (int u = 0; u < k; u++)
1479  {
1480  for (int v = 0; v < k; v++)
1481  {
1482  if ((v < r) && (u > v))
1483  wl = 0;
1484  else
1485  {
1486  w = tempMatrix[rowPermutation[u] * k + v];
1487  wl = pLength(w);
1488  }
1489  printf("%5d ", wl);
1490  }
1491  printf("\n");
1492  }
1493  printCounters ("", false);
1494 #endif
1495  if (r != 0)
1496  {
1497  divisor = tempMatrix[rowPermutation[r - 1] * k + r - 1];
1498  pNormalize(divisor);
1499  divisorLength = pLength(divisor);
1500  divisorLC = pGetCoeff(divisor);
1501  }
1502  for (int rr = r + 1; rr < k; rr++)
1503  for (int cc = r + 1; cc < k; cc++)
1504  {
1505  if (r == 0)
1506  elimOperationBucketNoDiv(tempMatrix[rowPermutation[rr] * k + cc],
1507  tempMatrix[rowPermutation[r] * k + r],
1508  tempMatrix[rowPermutation[r] * k + cc],
1509  tempMatrix[rowPermutation[rr] * k + r]);
1510  else
1511  elimOperationBucket(tempMatrix[rowPermutation[rr] * k + cc],
1512  tempMatrix[rowPermutation[r] * k + r],
1513  tempMatrix[rowPermutation[r] * k + cc],
1514  tempMatrix[rowPermutation[rr] * k + r],
1515  divisor, divisorLC, divisorLength);
1516  }
1517  }
1518 #if (defined COUNT_AND_PRINT_OPERATIONS) && (COUNT_AND_PRINT_OPERATIONS > 2)
1519  poly w = NULL; int wl = 0;
1520  printf("matrix after %d steps:\n", k - 1);
1521  for (int u = 0; u < k; u++)
1522  {
1523  for (int v = 0; v < k; v++)
1524  {
1525  if ((v < k - 1) && (u > v))
1526  wl = 0;
1527  else
1528  {
1529  w = tempMatrix[rowPermutation[u] * k + v];
1530  wl = pLength(w);
1531  }
1532  printf("%5d ", wl);
1533  }
1534  printf("\n");
1535  }
1536 #endif
1537  poly result = tempMatrix[rowPermutation[k - 1] * k + k - 1];
1538  if (sign == -1) result = pNeg(result);
1539  if (iSB != 0) result = kNF(iSB, currRing->qideal, result);
1540  PolyMinorValue mv(result, 0, 0, 0, 0, -1, -1);
1541  for (int i = 0; i < k * k; i++) pDelete(&tempMatrix[i]);
1542  omFreeSize(tempMatrix, k * k * sizeof(poly));
1543  delete[] rowPermutation;
1544  delete[] theColumns;
1545  delete[] theRows;
1546  return mv;
1547  }
1548 }
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
Definition: kstd1.cc:2819
poly getEntry(const int rowIndex, const int columnIndex) const
A method for retrieving the matrix entry.
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define pNeg(p)
Definition: polys.h:169
int k
Definition: cfEzgcd.cc:93
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy ...
Definition: monomials.h:51
#define omAlloc(size)
Definition: omAllocDecl.h:210
static int pLength(poly a)
Definition: p_polys.h:189
poly pp
Definition: myNF.cc:296
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
const ring r
Definition: syzextra.cc:208
void elimOperationBucketNoDiv(poly &p1, poly &p2, poly &p3, poly &p4)
int j
Definition: myNF.cc:70
#define assume(x)
Definition: mod2.h:405
void elimOperationBucket(poly &p1, poly &p2, poly &p3, poly &p4, poly &p5, number &c5, int p5Len)
pNormalize(P.p)
int i
Definition: cfEzgcd.cc:123
Class PolyMinorValue is derived from MinorValue and can be used for representing values in a cache fo...
Definition: Minor.h:799
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
#define NULL
Definition: omList.c:10
void printCounters(char *prefix, bool resetToZero)
void getAbsoluteColumnIndices(int *const target) const
A method for retrieving the 0-based indices of all columns encoded in this MinorKey.
Definition: Minor.cc:206
const CanonicalForm & w
Definition: facAbsFact.cc:55
#define pDelete(p_ptr)
Definition: polys.h:157
#define nSize(n)
Definition: numbers.h:39
#define pNext(p)
Definition: monomials.h:43
void getAbsoluteRowIndices(int *const target) const
A method for retrieving the 0-based indices of all rows encoded in this MinorKey. ...
Definition: Minor.cc:185
polyrec * poly
Definition: hilb.h:10
#define pSize(p)
Definition: polys.h:289
return result
Definition: facAbsBiFact.cc:76
int sign(const CanonicalForm &a)
#define pCopy(p)
return a copy of the poly
Definition: polys.h:156
PolyMinorValue PolyMinorProcessor::getMinorPrivateLaplace ( const int  k,
const MinorKey mk,
const bool  multipleMinors,
Cache< MinorKey, PolyMinorValue > &  c,
const ideal &  iSB 
)
private

A method for computing the value of a minor, using a cache.


The sub-matrix is specified by mk. Computation works recursively using Laplace's Theorem. We always develop along the row or column with the most zeros; see MinorProcessor::getBestLine (const int k, const MinorKey& mk). If an ideal is given, it is assumed to be a standard basis. In this case, all results will be reduced w.r.t. to this basis.

Parameters
kthe number of rows and columns in the minor to be comuted
mkthe representation of rows and columns of the minor to be comuted
multipleMinorsdecides whether we compute just one or all minors of a specified size
ca cache to be used for caching reusable sub-minors
iSBNULL or a standard basis
Returns
an instance of MinorValue representing the value of the corresponding minor
See also
MinorProcessor::getMinorPrivateLaplace (const int k, const MinorKey& mk, const ideal& iSB)

Definition at line 1083 of file MinorProcessor.cc.

1089 {
1090  assume(k > 0); /* k is the minor's dimension; the minor must be at least
1091  1x1 */
1092  /* The method works by recursion, and using Lapace's Theorem along
1093  the row/column with the most zeros. */
1094  if (k == 1)
1095  {
1097  mk.getAbsoluteColumnIndex(0)),
1098  0, 0, 0, 0, -1, -1);
1099  /* we set "-1" as, for k == 1, we do not have any cache retrievals */
1100  return pmv;
1101  }
1102  else
1103  {
1104  int b = getBestLine(k, mk); /* row or column with most
1105  zeros */
1106  poly result = NULL; /* This will contain the
1107  value of the minor. */
1108  int s = 0; int m = 0; int as = 0; int am = 0; /* counters for additions
1109  and multiplications,
1110  ..."a*" for accumulated
1111  operation counters */
1112  bool hadNonZeroEntry = false;
1113  if (b >= 0)
1114  {
1115  /* This means that the best line is the row with absolute (0-based)
1116  index b.
1117  Using Laplace, the sign of the contributing minors must be iterating;
1118  the initial sign depends on the relative index of b in
1119  minorRowKey: */
1120  int sign = (mk.getRelativeRowIndex(b) % 2 == 0 ? 1 : -1);
1121  poly signPoly = NULL;
1122  for (int c = 0; c < k; c++) /* This iterates over all involved columns. */
1123  {
1124  int absoluteC = mk.getAbsoluteColumnIndex(c);
1125  if (!isEntryZero(b, absoluteC)) /* Only then do we have to consider
1126  this sub-determinante. */
1127  {
1128  hadNonZeroEntry = true;
1129  PolyMinorValue mv; /* for storing all intermediate minors */
1130  /* Next MinorKey is mk with row b and column absoluteC omitted. */
1131  MinorKey subMk = mk.getSubMinorKey(b, absoluteC);
1132  if (cch.hasKey(subMk))
1133  { /* trying to find the result in the cache */
1134  mv = cch.getValue(subMk);
1135  mv.incrementRetrievals(); /* once more, we made use of the cached
1136  value for key mk */
1137  cch.put(subMk, mv); /* We need to do this with "put", as the
1138  (altered) number of retrievals may have an
1139  impact on the internal ordering among cache
1140  entries. */
1141  }
1142  else
1143  {
1144  /* recursive call: */
1145  mv = getMinorPrivateLaplace(k - 1, subMk, multipleMinors, cch,
1146  iSB);
1147  /* As this minor was not in the cache, we count the additions and
1148  multiplications that we needed to do in the recursive call: */
1149  m += mv.getMultiplications();
1150  s += mv.getAdditions();
1151  }
1152  /* In any case, we count all nested operations in the accumulative
1153  counters: */
1154  am += mv.getAccumulatedMultiplications();
1155  as += mv.getAccumulatedAdditions();
1156  pDelete(&signPoly);
1157  signPoly = pISet(sign);
1158  poly temp = pp_Mult_qq(mv.getResult(), getEntry(b, absoluteC),
1159  currRing);
1160  temp = p_Mult_q(signPoly, temp, currRing);
1161  result = p_Add_q(result, temp, currRing);
1162 #ifdef COUNT_AND_PRINT_OPERATIONS
1163  multsPoly++;
1164  addsPoly++;
1165  multsMon += pLength(mv.getResult()) * pLength(getEntry(b, absoluteC));
1166 #endif
1167  signPoly = NULL;
1168  s++; m++; as++; am++; /* This is for the addition and multiplication
1169  in the previous lines of code. */
1170  }
1171  sign = - sign; /* alternating the sign */
1172  }
1173  }
1174  else
1175  {
1176  b = - b - 1;
1177  /* This means that the best line is the column with absolute (0-based)
1178  index b.
1179  Using Laplace, the sign of the contributing minors must be iterating;
1180  the initial sign depends on the relative index of b in
1181  minorColumnKey: */
1182  int sign = (mk.getRelativeColumnIndex(b) % 2 == 0 ? 1 : -1);
1183  poly signPoly = NULL;
1184  for (int r = 0; r < k; r++) /* This iterates over all involved rows. */
1185  {
1186  int absoluteR = mk.getAbsoluteRowIndex(r);
1187  if (!isEntryZero(absoluteR, b)) /* Only then do we have to consider
1188  this sub-determinante. */
1189  {
1190  hadNonZeroEntry = true;
1191  PolyMinorValue mv; /* for storing all intermediate minors */
1192  /* Next MinorKey is mk with row absoluteR and column b omitted. */
1193  MinorKey subMk = mk.getSubMinorKey(absoluteR, b);
1194  if (cch.hasKey(subMk))
1195  { /* trying to find the result in the cache */
1196  mv = cch.getValue(subMk);
1197  mv.incrementRetrievals(); /* once more, we made use of the cached
1198  value for key mk */
1199  cch.put(subMk, mv); /* We need to do this with "put", as the
1200  (altered) number of retrievals may have an
1201  impact on the internal ordering among the
1202  cached entries. */
1203  }
1204  else
1205  {
1206  mv = getMinorPrivateLaplace(k - 1, subMk, multipleMinors, cch,
1207  iSB); /* recursive call */
1208  /* As this minor was not in the cache, we count the additions and
1209  multiplications that we needed to do in the recursive call: */
1210  m += mv.getMultiplications();
1211  s += mv.getAdditions();
1212  }
1213  /* In any case, we count all nested operations in the accumulative
1214  counters: */
1215  am += mv.getAccumulatedMultiplications();
1216  as += mv.getAccumulatedAdditions();
1217  pDelete(&signPoly);
1218  signPoly = pISet(sign);
1219  poly temp = pp_Mult_qq(mv.getResult(), getEntry(absoluteR, b),
1220  currRing);
1221  temp = p_Mult_q(signPoly, temp, currRing);
1222  result = p_Add_q(result, temp, currRing);
1223 #ifdef COUNT_AND_PRINT_OPERATIONS
1224  multsPoly++;
1225  addsPoly++;
1226  multsMon += pLength(mv.getResult()) * pLength(getEntry(absoluteR, b));
1227 #endif
1228  signPoly = NULL;
1229  s++; m++; as++; am++; /* This is for the addition and multiplication
1230  in the previous lines of code. */
1231  }
1232  sign = - sign; /* alternating the sign */
1233  }
1234  }
1235  /* Let's cache the newly computed minor: */
1236  int potentialRetrievals = NumberOfRetrievals(_containerRows,
1238  _minorSize,
1239  k,
1240  multipleMinors);
1241  if (hadNonZeroEntry)
1242  {
1243  s--; as--; /* first addition was 0 + ..., so we do not count it */
1244 #ifdef COUNT_AND_PRINT_OPERATIONS
1245  addsPoly--;
1246 #endif
1247  }
1248  if (s < 0) s = 0; /* may happen when all subminors are zero and no
1249  addition needs to be performed */
1250  if (as < 0) as = 0; /* may happen when all subminors are zero and no
1251  addition needs to be performed */
1252  if (iSB != 0) result = kNF(iSB, currRing->qideal, result);
1253  PolyMinorValue newMV(result, m, s, am, as, 1, potentialRetrievals);
1254  pDelete(&result); result = NULL;
1255  cch.put(mk, newMV); /* Here's the actual put inside the cache. */
1256  return newMV;
1257  }
1258 }
int getAccumulatedMultiplications() const
A method for accessing the multiplications performed while computing this minor, including all nested...
Definition: Minor.cc:894
const CanonicalForm int s
Definition: facAbsFact.cc:55
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
Definition: kstd1.cc:2819
int _containerColumns
private store for the number of columns in the container minor; This is set by MinorProcessor::define...
int getAccumulatedAdditions() const
A method for accessing the additions performed while computing this minor, including all nested addit...
Definition: Minor.cc:899
int getAbsoluteRowIndex(const int i) const
A method for retrieving the (0-based) index of the i-th row in the set of rows encoded in this...
Definition: Minor.cc:121
poly getEntry(const int rowIndex, const int columnIndex) const
A method for retrieving the matrix entry.
int k
Definition: cfEzgcd.cc:93
int _containerRows
private store for the number of rows in the container minor; This is set by MinorProcessor::defineSub...
MinorKey getSubMinorKey(const int absoluteEraseRowIndex, const int absoluteEraseColumnIndex) const
A method for retrieving a sub-MinorKey resulting from omitting one row and one column of this MinorKe...
Definition: Minor.cc:347
static int NumberOfRetrievals(const int rows, const int columns, const int containerMinorSize, const int minorSize, const bool multipleMinors)
A static method for computing the maximum number of retrievals of a minor.
void incrementRetrievals()
A method for incrementing the number of performed retrievals of this instance of MinorValue.
Definition: Minor.cc:874
static int pLength(poly a)
Definition: p_polys.h:189
int _minorSize
private store for the dimension of the minor(s) of interest
int getAdditions() const
A method for accessing the additions performed while computing this minor.
Definition: Minor.cc:889
int getRelativeColumnIndex(const int i) const
A method for retrieving the (0-based) relative index of the i-th column in this MinorKey.
Definition: Minor.cc:259
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
poly getResult() const
Accessor for the private field _result.
Definition: Minor.cc:1103
const ring r
Definition: syzextra.cc:208
int getBestLine(const int k, const MinorKey &mk) const
A method for identifying the row or column with the most zeros.
#define assume(x)
Definition: mod2.h:405
bool isEntryZero(const int absoluteRowIndex, const int absoluteColumnIndex) const
A method for testing whether a matrix entry is zero.
static poly pp_Mult_qq(poly p, poly q, const ring r)
Definition: p_polys.h:1076
int m
Definition: cfEzgcd.cc:119
int getRelativeRowIndex(const int i) const
A method for retrieving the (0-based) relative index of the i-th row in this MinorKey.
Definition: Minor.cc:227
int getAbsoluteColumnIndex(const int i) const
A method for retrieving the (0-based) index of the i-th column in the set of columns encoded in this...
Definition: Minor.cc:153
Class PolyMinorValue is derived from MinorValue and can be used for representing values in a cache fo...
Definition: Minor.h:799
int getMultiplications() const
A method for accessing the multiplications performed while computing this minor.
Definition: Minor.cc:884
Class MinorKey can be used for representing keys in a cache for sub-determinantes; see class Cache...
Definition: Minor.h:39
#define NULL
Definition: omList.c:10
#define pDelete(p_ptr)
Definition: polys.h:157
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:883
#define pISet(i)
Definition: polys.h:283
const poly b
Definition: syzextra.cc:213
static poly p_Mult_q(poly p, poly q, const ring r)
Definition: p_polys.h:1026
PolyMinorValue getMinorPrivateLaplace(const int k, const MinorKey &mk, const bool multipleMinors, Cache< MinorKey, PolyMinorValue > &c, const ideal &iSB)
A method for computing the value of a minor, using a cache.
return result
Definition: facAbsBiFact.cc:76
int sign(const CanonicalForm &a)
PolyMinorValue PolyMinorProcessor::getMinorPrivateLaplace ( const int  k,
const MinorKey mk,
const ideal &  iSB 
)
private

A method for computing the value of a minor, without using a cache.


The sub-matrix is specified by mk. Computation works recursively using Laplace's Theorem. We always develop along the row or column with the most zeros; see MinorProcessor::getBestLine (const int k, const MinorKey& mk). If an ideal is given, it is assumed to be a standard basis. In this case, all results will be reduced w.r.t. to this basis.

Parameters
kthe number of rows and columns in the minor to be comuted
mkthe representation of rows and columns of the minor to be comuted
iSBNULL or a standard basis
Returns
an instance of MinorValue representing the value of the corresponding minor
See also
MinorProcessor::getMinorPrivate (const int, const MinorKey&, const bool, Cache<MinorKey, MinorValue>&)

Definition at line 949 of file MinorProcessor.cc.

952 {
953  assume(k > 0); /* k is the minor's dimension; the minor must be at least
954  1x1 */
955  /* The method works by recursion, and using Lapace's Theorem along the
956  row/column with the most zeros. */
957  if (k == 1)
958  {
960  mk.getAbsoluteColumnIndex(0)),
961  0, 0, 0, 0, -1, -1);
962  /* "-1" is to signal that any statistics about the number of retrievals
963  does not make sense, as we do not use a cache. */
964  return pmv;
965  }
966  else
967  {
968  /* Here, the minor must be 2x2 or larger. */
969  int b = getBestLine(k, mk); /* row or column with most
970  zeros */
971  poly result = NULL; /* This will contain the
972  value of the minor. */
973  int s = 0; int m = 0; int as = 0; int am = 0; /* counters for additions
974  and multiplications,
975  ..."a*" for accumulated
976  operation counters */
977  bool hadNonZeroEntry = false;
978  if (b >= 0)
979  {
980  /* This means that the best line is the row with absolute (0-based)
981  index b.
982  Using Laplace, the sign of the contributing minors must be iterating;
983  the initial sign depends on the relative index of b in minorRowKey: */
984  int sign = (mk.getRelativeRowIndex(b) % 2 == 0 ? 1 : -1);
985  poly signPoly = NULL;
986  for (int c = 0; c < k; c++) /* This iterates over all involved columns. */
987  {
988  int absoluteC = mk.getAbsoluteColumnIndex(c);
989  if (!isEntryZero(b, absoluteC)) /* Only then do we have to consider
990  this sub-determinante. */
991  {
992  hadNonZeroEntry = true;
993  /* Next MinorKey is mk with row b and column absoluteC omitted. */
994  MinorKey subMk = mk.getSubMinorKey(b, absoluteC);
995  /* recursive call: */
996  PolyMinorValue mv = getMinorPrivateLaplace(k - 1, subMk, iSB);
997  m += mv.getMultiplications();
998  s += mv.getAdditions();
1000  as += mv.getAccumulatedAdditions();
1001  pDelete(&signPoly);
1002  signPoly = pISet(sign);
1003  poly temp = pp_Mult_qq(mv.getResult(), getEntry(b, absoluteC),
1004  currRing);
1005  temp = p_Mult_q(signPoly, temp, currRing);
1006  result = p_Add_q(result, temp, currRing);
1007 #ifdef COUNT_AND_PRINT_OPERATIONS
1008  multsPoly++;
1009  addsPoly++;
1010  multsMon += pLength(mv.getResult()) * pLength(getEntry(b, absoluteC));
1011 #endif
1012  signPoly = NULL;
1013  s++; m++; as++, am++; /* This is for the addition and multiplication
1014  in the previous lines of code. */
1015  }
1016  sign = - sign; /* alternating the sign */
1017  }
1018  }
1019  else
1020  {
1021  b = - b - 1;
1022  /* This means that the best line is the column with absolute (0-based)
1023  index b.
1024  Using Laplace, the sign of the contributing minors must be iterating;
1025  the initial sign depends on the relative index of b in
1026  minorColumnKey: */
1027  int sign = (mk.getRelativeColumnIndex(b) % 2 == 0 ? 1 : -1);
1028  poly signPoly = NULL;
1029  for (int r = 0; r < k; r++) /* This iterates over all involved rows. */
1030  {
1031  int absoluteR = mk.getAbsoluteRowIndex(r);
1032  if (!isEntryZero(absoluteR, b)) /* Only then do we have to consider
1033  this sub-determinante. */
1034  {
1035  hadNonZeroEntry = true;
1036  /* This is mk with row absoluteR and column b omitted. */
1037  MinorKey subMk = mk.getSubMinorKey(absoluteR, b);
1038  /* recursive call: */
1039  PolyMinorValue mv = getMinorPrivateLaplace(k - 1, subMk, iSB);
1040  m += mv.getMultiplications();
1041  s += mv.getAdditions();
1042  am += mv.getAccumulatedMultiplications();
1043  as += mv.getAccumulatedAdditions();
1044  pDelete(&signPoly);
1045  signPoly = pISet(sign);
1046  poly temp = pp_Mult_qq(mv.getResult(), getEntry(absoluteR, b),
1047  currRing);
1048  temp = p_Mult_q(signPoly, temp, currRing);
1049  result = p_Add_q(result, temp, currRing);
1050 #ifdef COUNT_AND_PRINT_OPERATIONS
1051  multsPoly++;
1052  addsPoly++;
1053  multsMon += pLength(mv.getResult()) * pLength(getEntry(absoluteR, b));
1054 #endif
1055  signPoly = NULL;
1056  s++; m++; as++, am++; /* This is for the addition and multiplication
1057  in the previous lines of code. */
1058  }
1059  sign = - sign; /* alternating the sign */
1060  }
1061  }
1062  if (hadNonZeroEntry)
1063  {
1064  s--; as--; /* first addition was 0 + ..., so we do not count it */
1065 #ifdef COUNT_AND_PRINT_OPERATIONS
1066  addsPoly--;
1067 #endif
1068  }
1069  if (s < 0) s = 0; /* may happen when all subminors are zero and no
1070  addition needs to be performed */
1071  if (as < 0) as = 0; /* may happen when all subminors are zero and no
1072  addition needs to be performed */
1073  if (iSB != 0) result = kNF(iSB, currRing->qideal, result);
1074  PolyMinorValue newMV(result, m, s, am, as, -1, -1);
1075  /* "-1" is to signal that any statistics about the number of retrievals
1076  does not make sense, as we do not use a cache. */
1077  pDelete(&result);
1078  return newMV;
1079  }
1080 }
int getAccumulatedMultiplications() const
A method for accessing the multiplications performed while computing this minor, including all nested...
Definition: Minor.cc:894
const CanonicalForm int s
Definition: facAbsFact.cc:55
poly kNF(ideal F, ideal Q, poly p, int syzComp, int lazyReduce)
Definition: kstd1.cc:2819
int getAccumulatedAdditions() const
A method for accessing the additions performed while computing this minor, including all nested addit...
Definition: Minor.cc:899
int getAbsoluteRowIndex(const int i) const
A method for retrieving the (0-based) index of the i-th row in the set of rows encoded in this...
Definition: Minor.cc:121
poly getEntry(const int rowIndex, const int columnIndex) const
A method for retrieving the matrix entry.
int k
Definition: cfEzgcd.cc:93
MinorKey getSubMinorKey(const int absoluteEraseRowIndex, const int absoluteEraseColumnIndex) const
A method for retrieving a sub-MinorKey resulting from omitting one row and one column of this MinorKe...
Definition: Minor.cc:347
static int pLength(poly a)
Definition: p_polys.h:189
int getAdditions() const
A method for accessing the additions performed while computing this minor.
Definition: Minor.cc:889
int getRelativeColumnIndex(const int i) const
A method for retrieving the (0-based) relative index of the i-th column in this MinorKey.
Definition: Minor.cc:259
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:12
poly getResult() const
Accessor for the private field _result.
Definition: Minor.cc:1103
const ring r
Definition: syzextra.cc:208
int getBestLine(const int k, const MinorKey &mk) const
A method for identifying the row or column with the most zeros.
#define assume(x)
Definition: mod2.h:405
bool isEntryZero(const int absoluteRowIndex, const int absoluteColumnIndex) const
A method for testing whether a matrix entry is zero.
static poly pp_Mult_qq(poly p, poly q, const ring r)
Definition: p_polys.h:1076
int m
Definition: cfEzgcd.cc:119
int getRelativeRowIndex(const int i) const
A method for retrieving the (0-based) relative index of the i-th row in this MinorKey.
Definition: Minor.cc:227
int getAbsoluteColumnIndex(const int i) const
A method for retrieving the (0-based) index of the i-th column in the set of columns encoded in this...
Definition: Minor.cc:153
Class PolyMinorValue is derived from MinorValue and can be used for representing values in a cache fo...
Definition: Minor.h:799
int getMultiplications() const
A method for accessing the multiplications performed while computing this minor.
Definition: Minor.cc:884
Class MinorKey can be used for representing keys in a cache for sub-determinantes; see class Cache...
Definition: Minor.h:39
#define NULL
Definition: omList.c:10
#define pDelete(p_ptr)
Definition: polys.h:157
polyrec * poly
Definition: hilb.h:10
static poly p_Add_q(poly p, poly q, const ring r)
Definition: p_polys.h:883
#define pISet(i)
Definition: polys.h:283
const poly b
Definition: syzextra.cc:213
static poly p_Mult_q(poly p, poly q, const ring r)
Definition: p_polys.h:1026
PolyMinorValue getMinorPrivateLaplace(const int k, const MinorKey &mk, const bool multipleMinors, Cache< MinorKey, PolyMinorValue > &c, const ideal &iSB)
A method for computing the value of a minor, using a cache.
return result
Definition: facAbsBiFact.cc:76
int sign(const CanonicalForm &a)
PolyMinorValue PolyMinorProcessor::getNextMinor ( const char *  algorithm,
const ideal &  iSB 
)

A method for obtaining the next minor when iterating through all minors of a given size within a pre-defined sub-matrix of an underlying matrix.


This method should only be called after MinorProcessor::hasNextMinor () had been called and yielded true.
Computation works either by Laplace's algorithm (without using a cache) or by Bareiss's algorithm.
If an ideal is given, it is assumed to be a standard basis. In this case, all results will be reduced w.r.t. to this basis.

Parameters
algorithmeither "Laplace" or "Bareiss"
iSBNULL or a standard basis
Returns
true iff there is a next choice of rows and columns
See also
PolyMinorValue::getNextMinor (Cache<MinorKey, PolyMinorValue>& c, const ideal& iSB)

Definition at line 924 of file MinorProcessor.cc.

926 {
927  /* call a helper method which computes the minor (without using a
928  cache): */
929  if (strcmp(algorithm, "Laplace") == 0)
931  else if (strcmp(algorithm, "Bareiss") == 0)
933  else assume(false);
934 
935  /* The following code is never reached and just there to make the
936  compiler happy: */
937  return PolyMinorValue();
938 }
PolyMinorValue getMinorPrivateBareiss(const int k, const MinorKey &mk, const ideal &iSB)
A method for computing the value of a minor, without using a cache.
MinorKey _minor
private store for the rows and columns of the minor of interest; Usually, this minor will encode subs...
int _minorSize
private store for the dimension of the minor(s) of interest
#define assume(x)
Definition: mod2.h:405
Class PolyMinorValue is derived from MinorValue and can be used for representing values in a cache fo...
Definition: Minor.h:799
PolyMinorValue getMinorPrivateLaplace(const int k, const MinorKey &mk, const bool multipleMinors, Cache< MinorKey, PolyMinorValue > &c, const ideal &iSB)
A method for computing the value of a minor, using a cache.
PolyMinorValue PolyMinorProcessor::getNextMinor ( Cache< MinorKey, PolyMinorValue > &  c,
const ideal &  iSB 
)

A method for obtaining the next minor when iterating through all minors of a given size within a pre-defined sub-matrix of an underlying matrix.


This method should only be called after MinorProcessor::hasNextMinor () had been called and yielded true.
Computation works using Laplace's algorithm and a cache c which may already contain useful results from previous calls of PolyMinorValue::getNextMinor (Cache<MinorKey, PolyMinorValue>& c, const ideal& iSB). If an ideal is given, it is assumed to be a standard basis. In this case, all results will be reduced w.r.t. to this basis.

Parameters
iSBNULL or a standard basis
Returns
the next minor
See also
PolyMinorValue::getNextMinor (const char* algorithm, const ideal& iSB)

Definition at line 940 of file MinorProcessor.cc.

943 {
944  /* computation with cache */
945  return getMinorPrivateLaplace(_minorSize, _minor, true, c, iSB);
946 }
MinorKey _minor
private store for the rows and columns of the minor of interest; Usually, this minor will encode subs...
int _minorSize
private store for the dimension of the minor(s) of interest
PolyMinorValue getMinorPrivateLaplace(const int k, const MinorKey &mk, const bool multipleMinors, Cache< MinorKey, PolyMinorValue > &c, const ideal &iSB)
A method for computing the value of a minor, using a cache.
bool PolyMinorProcessor::isEntryZero ( const int  absoluteRowIndex,
const int  absoluteColumnIndex 
) const
protectedvirtual

A method for testing whether a matrix entry is zero.

Parameters
absoluteRowIndexthe absolute (zero-based) row index
absoluteColumnIndexthe absolute (zero-based) column index
Returns
true iff the specified matrix entry is zero

Reimplemented from MinorProcessor.

Definition at line 820 of file MinorProcessor.cc.

822 {
823  return getEntry(absoluteRowIndex, absoluteColumnIndex) == NULL;
824 }
poly getEntry(const int rowIndex, const int columnIndex) const
A method for retrieving the matrix entry.
#define NULL
Definition: omList.c:10
string PolyMinorProcessor::toString ( ) const
virtual

A method for providing a printable version of the represented MinorProcessor.

Returns
a printable version of the given instance as instance of class string

Reimplemented from MinorProcessor.

Definition at line 826 of file MinorProcessor.cc.

827 {
828  char h[32];
829  string t = "";
830  string s = "PolyMinorProcessor:";
831  s += "\n matrix: ";
832  sprintf(h, "%d", _rows); s += h;
833  s += " x ";
834  sprintf(h, "%d", _columns); s += h;
835  int myIndexArray[500];
836  s += "\n considered submatrix has row indices: ";
837  _container.getAbsoluteRowIndices(myIndexArray);
838  for (int k = 0; k < _containerRows; k++)
839  {
840  if (k != 0) s += ", ";
841  sprintf(h, "%d", myIndexArray[k]); s += h;
842  }
843  s += " (first row of matrix has index 0)";
844  s += "\n considered submatrix has column indices: ";
845  _container.getAbsoluteColumnIndices(myIndexArray);
846  for (int k = 0; k < _containerColumns; k++)
847  {
848  if (k != 0) s += ", ";
849  sprintf(h, "%d", myIndexArray[k]); s += h;
850  }
851  s += " (first column of matrix has index 0)";
852  s += "\n size of considered minor(s): ";
853  sprintf(h, "%d", _minorSize); s += h;
854  s += "x";
855  s += h;
856  return s;
857 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
int _containerColumns
private store for the number of columns in the container minor; This is set by MinorProcessor::define...
int _rows
private store for the number of rows in the underlying matrix
int _columns
private store for the number of columns in the underlying matrix
int k
Definition: cfEzgcd.cc:93
int _containerRows
private store for the number of rows in the container minor; This is set by MinorProcessor::defineSub...
int _minorSize
private store for the dimension of the minor(s) of interest
MinorKey _container
private store for the rows and columns of the container minor within the underlying matrix; _containe...
void getAbsoluteColumnIndices(int *const target) const
A method for retrieving the 0-based indices of all columns encoded in this MinorKey.
Definition: Minor.cc:206
void getAbsoluteRowIndices(int *const target) const
A method for retrieving the 0-based indices of all rows encoded in this MinorKey. ...
Definition: Minor.cc:185
static Poly * h
Definition: janet.cc:978

Field Documentation

poly* PolyMinorProcessor::_polyMatrix
private

private store for polynomial matrix entries

Definition at line 569 of file MinorProcessor.h.


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