Changeset 95a6f3 in git for Singular/MinorProcessor.cc

Timestamp:

Oct 9, 2009, 3:46:30 PM (15 years ago)

Author:

Frank Seelisch <seelisch@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

60e4be265398f8004f3b093179a74b59f4fdcb74

Parents:

70f63ab39d1a6a435e42e041336a21e13c1269d9

Message:

more functionality: compute int minors modulo p


git-svn-id: file:///usr/local/Singular/svn/trunk@12182 2c84dea3-7e68-4137-9b89-c4e89433aadc

File:

• Singular/MinorProcessor.cc (modified) (10 diffs)

Singular/MinorProcessor.cc

@@ -270 +270 @@
 
 IntMinorValue IntMinorProcessor::getMinor(const int dimension, const int* rowIndices, const int* columnIndices,
-                                            Cache<MinorKey, IntMinorValue>& c) {
+                                            Cache<MinorKey, IntMinorValue>& c, const int characteristic) {
     defineSubMatrix(dimension, rowIndices, dimension, columnIndices);
     _minorSize = dimension;
     // call a helper method which recursively computes the minor using the cache c:
-    return getMinorPrivate(dimension, _container, false, c);
-}
-
-IntMinorValue IntMinorProcessor::getMinor(const int dimension, const int* rowIndices, const int* columnIndices) {
+    return getMinorPrivate(dimension, _container, false, c, characteristic);
+}
+
+IntMinorValue IntMinorProcessor::getMinor(const int dimension, const int* rowIndices, const int* columnIndices, const int characteristic) {
     defineSubMatrix(dimension, rowIndices, dimension, columnIndices);
     _minorSize = dimension;
     // call a helper method which recursively computes the minor (without using a cache):
-    return getMinorPrivate(_minorSize, _container);
-}
-
-IntMinorValue IntMinorProcessor::getNextMinor() {
+    return getMinorPrivate(_minorSize, _container, characteristic);
+}
+
+IntMinorValue IntMinorProcessor::getNextMinor(const int characteristic) {
     // computation without cache
-    return getMinorPrivate(_minorSize, _minor);
-}
-
-IntMinorValue IntMinorProcessor::getNextMinor(Cache<MinorKey, IntMinorValue>& c) {
+    return getMinorPrivate(_minorSize, _minor, characteristic);
+}
+
+IntMinorValue IntMinorProcessor::getNextMinor(Cache<MinorKey, IntMinorValue>& c, const int characteristic) {
     // computation with cache
-    return getMinorPrivate(_minorSize, _minor, true, c);
-}
-
-IntMinorValue IntMinorProcessor::getMinorPrivate(const int k, const MinorKey& mk) {
+    return getMinorPrivate(_minorSize, _minor, true, c, characteristic);
+}
+
+IntMinorValue IntMinorProcessor::getMinorPrivate(const int k, const MinorKey& mk, const int characteristic) {
     assert(k > 0); // k is the minor's dimension; the minor must be at least 1x1
     // The method works by recursion, and using Lapace's Theorem along the row/column with the most zeros.
@@ -317 +317 @@
                 MinorKey subMk = mk.getSubMinorKey(b, absoluteC);  // This is MinorKey when we omit row b and column absoluteC.
                 if (_matrix[b][absoluteC] != 0) { // Only then do we have to consider this sub-determinante.
-                    IntMinorValue mv = getMinorPrivate(k - 1, subMk);  // recursive call
+                    IntMinorValue mv = getMinorPrivate(k - 1, subMk, characteristic);  // recursive call
                     m += mv.getMultiplications();
                     s += mv.getAdditions();
@@ -324 +324 @@
                     result += sign * mv.getResult() * _matrix[b][absoluteC]; // adding sub-determinante times matrix entry
                                                                              // times appropriate sign
+                    if (characteristic != 0) result = result % characteristic;
                     s++; m++; as++, am++; // This is for the addition and multiplication in the previous line of code.
                 }
@@ -339 +340 @@
                 MinorKey subMk = mk.getSubMinorKey(absoluteR, b); // This is MinorKey when we omit row absoluteR and column b.
                 if (_matrix[absoluteR][b] != 0) { // Only then do we have to consider this sub-determinante.
-                    IntMinorValue mv = getMinorPrivate(k - 1, subMk);  // recursive call
+                    IntMinorValue mv = getMinorPrivate(k - 1, subMk, characteristic);  // recursive call
                     m += mv.getMultiplications();
                     s += mv.getAdditions();
@@ -346 +347 @@
                     result += sign * mv.getResult() * _matrix[absoluteR][b]; // adding sub-determinante times matrix entry
                                                                              // times appropriate sign
+                    if (characteristic != 0) result = result % characteristic;
                     s++; m++; as++, am++; // This is for the addition and multiplication in the previous line of code.
                 }
@@ -362 +364 @@
 
 IntMinorValue IntMinorProcessor::getMinorPrivate(const int k, const MinorKey& mk,
-                                                   const bool multipleMinors,
-                                                   Cache<MinorKey, IntMinorValue>& cch) {
+                                                 const bool multipleMinors,
+                                                 Cache<MinorKey, IntMinorValue>& cch,
+                                                 const int characteristic) {
     assert(k > 0); // k is the minor's dimension; the minor must be at least 1x1
     // The method works by recursion, and using Lapace's Theorem along the row/column with the most zeros.
@@ -392 +395 @@
                     }
                     else {
-                        mv = getMinorPrivate(k - 1, subMk, multipleMinors, cch); // recursive call
+                        mv = getMinorPrivate(k - 1, subMk, multipleMinors, cch, characteristic); // recursive call
                         // As this minor was not in the cache, we count the additions and
                         // multiplications that we needed to do in the recursive call:
@@ -403 +406 @@
                     result += sign * mv.getResult() * _matrix[b][absoluteC]; // adding sub-determinante times matrix entry
                                                                              // times appropriate sign
+                    if (characteristic != 0) result = result % characteristic;
                     s++; m++; as++; am++; // This is for the addition and multiplication in the previous line of code.
                 }
@@ -425 +429 @@
                     }
                     else {
-                        mv = getMinorPrivate(k - 1, subMk, multipleMinors, cch); // recursive call
+                        mv = getMinorPrivate(k - 1, subMk, multipleMinors, cch, characteristic); // recursive call
                         // As this minor was not in the cache, we count the additions and
                         // multiplications that we needed to do in the recursive call:
@@ -436 +440 @@
                     result += sign * mv.getResult() * _matrix[absoluteR][b]; // adding sub-determinante times matrix entry
                                                                              // times appropriate sign
+                    if (characteristic != 0) result = result % characteristic;
                     s++; m++; as++; am++; // This is for the addition and multiplication in the previous line of code.
                 }