[f0fd47] | 1 | #ifndef MINOR_INTERFACE_H |
---|
| 2 | #define MINOR_INTERFACE_H |
---|
| 3 | |
---|
| 4 | /* all computations are module char, if char <> 0; |
---|
| 5 | if additionally, an ideal i != NULL is given, then computations are |
---|
| 6 | modulo i (in this case, i is assumed to be a standard basis); |
---|
| 7 | if k = 0, then all non-zero minors are requested, otherwise |
---|
| 8 | if k > 0, then the first k non-zero minors are requested, |
---|
| 9 | if k < 0, then the first |k| minors (zero is allowed) are requested, |
---|
| 10 | (note that k <> 0 may result in a smaller number k' of |
---|
| 11 | minors if there are only k' < |k| minors; |
---|
| 12 | if an algorithm is provided, it must be one of "Bareiss" or |
---|
| 13 | "Laplace"; when a cache is used, the underlying algorithm |
---|
| 14 | is automatically Laplace */ |
---|
| 15 | |
---|
| 16 | /** |
---|
| 17 | * Returns the specified set of minors (= subdeterminantes) of the |
---|
| 18 | * given matrix. These minors form the set of generators of the ideal |
---|
| 19 | * which is actually returned.<br> |
---|
| 20 | * If k == 0, all non-zero minors will be computed. For k > 0, only |
---|
| 21 | * the first k non-zero minors (to some fixed ordering among all minors) |
---|
| 22 | * will be computed. Use k < 0 to compute the first |k| minors (including |
---|
| 23 | * zero minors).<br> |
---|
| 24 | * algorithm must be one of "Bareiss" and "Laplace".<br> |
---|
| 25 | * i must be either NULL or an ideal capturing a standard basis. In the |
---|
| 26 | * later case all minors will be reduced w.r.t. i. |
---|
| 27 | * If allDifferent is true, each minor will be included as generator |
---|
| 28 | * in the resulting ideal only once; otherwise as often as it occurs as |
---|
| 29 | * minor value during the computation. |
---|
| 30 | * @param m the matrix from which to compute minors |
---|
| 31 | * @param minorSize the size of the minors to be computed |
---|
| 32 | * @param k the number of minors to be computed |
---|
| 33 | * @param algorithm the algorithm to be used for the computation |
---|
| 34 | * @param i NULL or an ideal which encodes a standard basis |
---|
| 35 | * @param allDifferent if true each minor is considered only once |
---|
| 36 | * @return the ideal which has as generators the specified set of minors |
---|
| 37 | */ |
---|
| 38 | ideal getMinorIdeal (const matrix m, const int minorSize, const int k, |
---|
| 39 | const char* algorithm, const ideal i, |
---|
| 40 | const bool allDifferent); |
---|
| 41 | |
---|
| 42 | /** |
---|
| 43 | * Returns the specified set of minors (= subdeterminantes) of the |
---|
| 44 | * given matrix. These minors form the set of generators of the ideal |
---|
| 45 | * which is actually returned.<br> |
---|
| 46 | * If k == 0, all non-zero minors will be computed. For k > 0, only |
---|
| 47 | * the first k non-zero minors (to some fixed ordering among all minors) |
---|
| 48 | * will be computed. Use k < 0 to compute the first |k| minors (including |
---|
| 49 | * zero minors).<br> |
---|
| 50 | * The underlying algorithm is Laplace's algorithm with caching of certain |
---|
| 51 | * subdeterminantes. The caching strategy can be set; see |
---|
| 52 | * int MinorValue::getUtility () const in Minor.cc. cacheN is the maximum |
---|
| 53 | * number of cached polynomials (=subdeterminantes); cacheW the maximum |
---|
| 54 | * weight of the cache during all computations.<br> |
---|
| 55 | * i must be either NULL or an ideal capturing a standard basis. In the |
---|
| 56 | * later case all minors will be reduced w.r.t. i. |
---|
| 57 | * If allDifferent is true, each minor will be included as generator |
---|
| 58 | * in the resulting ideal only once; otherwise as often as it occurs as |
---|
| 59 | * minor value during the computation. |
---|
| 60 | * @param m the matrix from which to compute minors |
---|
| 61 | * @param minorSize the size of the minors to be computed |
---|
| 62 | * @param k the number of minors to be computed |
---|
| 63 | * @param i NULL or an ideal which encodes a standard basis |
---|
| 64 | * @param cacheStrategy one of {1, .., 5}; see Minor.cc |
---|
| 65 | * @param cacheN maximum number of cached polynomials (=subdeterminantes) |
---|
| 66 | * @param cacheW maximum weight of the cache |
---|
| 67 | * @param allDifferent if true each minor is considered only once |
---|
| 68 | * @return the ideal which has as generators the specified set of minors |
---|
| 69 | */ |
---|
| 70 | ideal getMinorIdealCache (const matrix m, const int minorSize, const int k, |
---|
| 71 | const ideal i, const int cacheStrategy, |
---|
| 72 | const int cacheN, const int cacheW, |
---|
| 73 | const bool allDifferent); |
---|
| 74 | |
---|
| 75 | /** |
---|
| 76 | * Returns the specified set of minors (= subdeterminantes) of the |
---|
| 77 | * given matrix. These minors form the set of generators of the ideal |
---|
| 78 | * which is actually returned.<br> |
---|
| 79 | * If k == 0, all non-zero minors will be computed. For k > 0, only |
---|
| 80 | * the first k non-zero minors (to some fixed ordering among all minors) |
---|
| 81 | * will be computed. Use k < 0 to compute the first |k| minors (including |
---|
| 82 | * zero minors).<br> |
---|
| 83 | * The algorithm is heuristically chosen among "Bareiss", "Laplace", |
---|
| 84 | * and Laplace with caching (of subdeterminants).<br> |
---|
| 85 | * i must be either NULL or an ideal capturing a standard basis. In the |
---|
| 86 | * later case all minors will be reduced w.r.t. i. |
---|
| 87 | * If allDifferent is true, each minor will be included as generator |
---|
| 88 | * in the resulting ideal only once; otherwise as often as it occurs as |
---|
| 89 | * minor value during the computation. |
---|
| 90 | * @param m the matrix from which to compute minors |
---|
| 91 | * @param minorSize the size of the minors to be computed |
---|
| 92 | * @param k the number of minors to be computed |
---|
| 93 | * @param i NULL or an ideal which encodes a standard basis |
---|
| 94 | * @param allDifferent if true each minor is considered only once |
---|
| 95 | * @return the ideal which has as generators the specified set of minors |
---|
| 96 | */ |
---|
| 97 | ideal getMinorIdealHeuristic (const matrix m, const int minorSize, |
---|
| 98 | const int k, const ideal i, |
---|
| 99 | const bool allDifferent); |
---|
| 100 | |
---|
| 101 | #endif |
---|
| 102 | /* MINOR_INTERFACE_H */ |
---|