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