3 * Collection of all flags used through the GiNaC framework. */
6 * GiNaC Copyright (C) 1999-2007 Johannes Gutenberg University Mainz, Germany
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 #ifndef __GINAC_FLAGS_H__
24 #define __GINAC_FLAGS_H__
28 /** Flags to control the behavior of expand(). */
29 class expand_options {
32 expand_indexed = 0x0001, ///< expands (a+b).i to a.i+b.i
33 expand_function_args = 0x0002 ///< expands the arguments of functions
37 /** Flags to control the behavior of has(). */
41 algebraic = 0x0001, ///< enable algebraic matching
45 /** Flags to control the behavior of subs(). */
49 no_pattern = 0x0001, ///< disable pattern matching
50 subs_no_pattern = 0x0001, // for backwards compatibility
51 algebraic = 0x0002, ///< enable algebraic substitutions
52 subs_algebraic = 0x0002, // for backwards compatibility
53 pattern_is_product = 0x0004, ///< used internally by expairseq::subschildren()
54 pattern_is_not_product = 0x0008, ///< used internally by expairseq::subschildren()
55 no_index_renaming = 0x0010,
56 // To indicate that we want to substitue an index by something that is
57 // is not an index. Without this flag the index value would be
58 // substituted in that case.
59 really_subs_idx = 0x0020
63 /** Domain of an object */
73 /** Flags to control series expansion. */
74 class series_options {
77 /** Suppress branch cuts in series expansion. Branch cuts manifest
78 * themselves as step functions, if this option is not passed. If
79 * it is passed and expansion at a point on a cut is performed, then
80 * the analytic continuation of the function is expanded. */
81 suppress_branchcut = 0x0001
85 /** Switch to control algorithm for determinant computation. */
86 class determinant_algo {
89 /** Let the system choose. A heuristics is applied for automatic
90 * determination of a suitable algorithm. */
92 /** Gauss elimination. If \f$m_{i,j}^{(0)}\f$ are the entries of the
93 * original matrix, then the matrix is transformed into triangular
94 * form by applying the rules
96 * m_{i,j}^{(k+1)} = m_{i,j}^{(k)} - m_{i,k}^{(k)} m_{k,j}^{(k)} / m_{k,k}^{(k)}
98 * The determinant is then just the product of diagonal elements.
99 * Choose this algorithm only for purely numerical matrices. */
101 /** Division-free elimination. This is a modification of Gauss
102 * elimination where the division by the pivot element is not
103 * carried out. If \f$m_{i,j}^{(0)}\f$ are the entries of the
104 * original matrix, then the matrix is transformed into triangular
105 * form by applying the rules
107 * m_{i,j}^{(k+1)} = m_{i,j}^{(k)} m_{k,k}^{(k)} - m_{i,k}^{(k)} m_{k,j}^{(k)}
109 * The determinant can later be computed by inspecting the diagonal
110 * elements only. This algorithm is only there for the purpose of
111 * cross-checks. It is never fast. */
113 /** Laplace elimination. This is plain recursive elimination along
114 * minors although multiple minors are avoided by the algorithm.
115 * Although the algorithm is exponential in complexity it is
116 * frequently the fastest one when the matrix is populated by
117 * complicated symbolic expressions. */
119 /** Bareiss fraction-free elimination. This is a modification of
120 * Gauss elimination where the division by the pivot element is
121 * <EM>delayed</EM> until it can be carried out without computing
122 * GCDs. If \f$m_{i,j}^{(0)}\f$ are the entries of the original
123 * matrix, then the matrix is transformed into triangular form by
126 * m_{i,j}^{(k+1)} = (m_{i,j}^{(k)} m_{k,k}^{(k)} - m_{i,k}^{(k)} m_{k,j}^{(k)}) / m_{k-1,k-1}^{(k-1)}
128 * (We have set \f$m_{-1,-1}^{(-1)}=1\f$ in order to avoid a case
129 * distinction in above formula.) It can be shown that nothing more
130 * than polynomial long division is needed for carrying out the
131 * division. The determinant can then be read of from the lower
132 * right entry. This algorithm is rarely fast for computing
138 /** Switch to control algorithm for linear system solving. */
142 /** Let the system choose. A heuristics is applied for automatic
143 * determination of a suitable algorithm. */
145 /** Gauss elimination. If \f$m_{i,j}^{(0)}\f$ are the entries of the
146 * original matrix, then the matrix is transformed into triangular
147 * form by applying the rules
149 * m_{i,j}^{(k+1)} = m_{i,j}^{(k)} - m_{i,k}^{(k)} m_{k,j}^{(k)} / m_{k,k}^{(k)}
151 * This algorithm is well-suited for numerical matrices but generally
152 * suffers from the expensive division (and computation of GCDs) at
155 /** Division-free elimination. This is a modification of Gauss
156 * elimination where the division by the pivot element is not
157 * carried out. If \f$m_{i,j}^{(0)}\f$ are the entries of the
158 * original matrix, then the matrix is transformed into triangular
159 * form by applying the rules
161 * m_{i,j}^{(k+1)} = m_{i,j}^{(k)} m_{k,k}^{(k)} - m_{i,k}^{(k)} m_{k,j}^{(k)}
163 * This algorithm is only there for the purpose of cross-checks.
164 * It suffers from exponential intermediate expression swell. Use it
165 * only for small systems. */
167 /** Bareiss fraction-free elimination. This is a modification of
168 * Gauss elimination where the division by the pivot element is
169 * <EM>delayed</EM> until it can be carried out without computing
170 * GCDs. If \f$m_{i,j}^{(0)}\f$ are the entries of the original
171 * matrix, then the matrix is transformed into triangular form by
174 * m_{i,j}^{(k+1)} = (m_{i,j}^{(k)} m_{k,k}^{(k)} - m_{i,k}^{(k)} m_{k,j}^{(k)}) / m_{k-1,k-1}^{(k-1)}
176 * (We have set \f$m_{-1,-1}^{(-1)}=1\f$ in order to avoid a case
177 * distinction in above formula.) It can be shown that nothing more
178 * than polynomial long division is needed for carrying out the
179 * division. This is generally the fastest algorithm for solving
180 * linear systems. In contrast to division-free elimination it only
181 * has a linear expression swell. For two-dimensional systems, the
182 * two algorithms are equivalent, however. */
187 /** Flags to store information about the state of an object.
188 * @see basic::flags */
192 dynallocated = 0x0001, ///< heap-allocated (i.e. created by new if we want to be clever and bypass the stack, @see ex::construct_from_basic() )
193 evaluated = 0x0002, ///< .eval() has already done its job
194 expanded = 0x0004, ///< .expand(0) has already done its job (other expand() options ignore this flag)
195 hash_calculated = 0x0008, ///< .calchash() has already done its job
196 not_shareable = 0x0010 ///< don't share instances of this object between different expressions unless explicitly asked to (used by ex::compare())
200 /** Possible attributes an object can have. */
204 // answered by class numeric and symbols/constants in particular domains
221 // answered by class relation
226 relation_less_or_equal,
228 relation_greater_or_equal,
230 // answered by class symbol
233 // answered by class lst
236 // answered by class exprseq
239 // answered by classes numeric, symbol, add, mul, power
244 crational_polynomial,
248 // answered by class indexed
249 indexed, // class can carry indices
250 has_indices, // object has at least one index
252 // answered by class idx
262 noncommutative_composite
266 /** Strategies how to clean up the function remember cache.
267 * @see remember_table */
268 class remember_strategies {
271 delete_never, ///< Let table grow undefinitely
272 delete_lru, ///< Least recently used
273 delete_lfu, ///< Least frequently used
274 delete_cyclic ///< First (oldest) one in list
280 #endif // ndef __GINAC_FLAGS_H__