source: git/Singular/MinorInterface.h @ 020ef9

spielwiese
Last change on this file since 020ef9 was 5c44339, checked in by Frank Seelisch <seelisch@…>, 14 years ago
facilities for printing out operation counters for '*' and '+' git-svn-id: file:///usr/local/Singular/svn/trunk@12691 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 5.1 KB
Line 
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*/
38ideal 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*/
70ideal 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*/
97ideal 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 */
Note: See TracBrowser for help on using the repository browser.