source: git/Singular/MinorInterface.h @ 0df59c8

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